Class ObjectMap<V>

A map that is backed by an object-like map. Use objectMap to create it.

Type Parameters

Hierarchy

BaseModel<
    {
        $modelId: ModelIdProp<string> & {
            typedAs<T extends string>(): ModelIdProp<T>;
        };
        items: OptionalModelProp<{ [k: string]: any }>;
    },
    never,
    never,
    "$modelId",
    this,
> & Omit<{ $modelId: string; items: { [k: string]: any } }, BaseModelKeys> & {}
- ObjectMap

Implements

Map<string, V>

Index

Constructors

constructor

new ObjectMap<V>(
    data: ModelPropsToTransformedCreationData<
        {
            $modelId: ModelIdProp<string> & {
                typedAs<T extends string>(): ModelIdProp<T>;
            };
            items: OptionalModelProp<{ [k: string]: any }>;
        },
    >,
): ObjectMap<V>
Type Parameters
- V
Parameters
- data: ModelPropsToTransformedCreationData<
      {
          $modelId: ModelIdProp<string> & {
              typedAs<T extends string>(): ModelIdProp<T>;
          };
          items: OptionalModelProp<{ [k: string]: any }>;
      },
  >
Returns ObjectMap<V>
Inherited from Model({ [modelIdKey]: idProp, items: tProp(typesRecord(typesUnchecked<any>()), () => ({})), // will be properly checked by types.objectMap(subType) }).constructor

Properties

[fromSnapshotOverrideTypeSymbol]

"[fromSnapshotOverrideTypeSymbol]": never

[modelIdPropertyNameSymbol]

"[modelIdPropertyNameSymbol]": "$modelId"

[propsTypeSymbol]

"[propsTypeSymbol]": {
    $modelId: ModelIdProp<string> & {
        typedAs<T extends string>(): ModelIdProp<T>;
    };
    items: OptionalModelProp<{ [k: string]: any }>;
}

[toSnapshotOverrideTypeSymbol]

"[toSnapshotOverrideTypeSymbol]": never

`Readonly`[toStringTag]

"[toStringTag]": "ObjectMap"

`Readonly`$

$: { $modelId: string; items: { [k: string]: any } }

Data part of the model, which is observable and will be serialized in snapshots. Use it if one of the data properties matches one of the model properties/functions.

`Readonly`$modelType

$modelType: string

Model type name.

items

items: { [k: string]: any } = ...

Accessors

$modelId

get $modelId(): ModelIdPropertyType<TProps, ModelIdPropertyName>
Model internal id. Can be modified inside a model action. It will return undefined if there's no id prop set.

Returns ModelIdPropertyType<TProps, ModelIdPropertyName>
Inherited from Model({ [modelIdKey]: idProp, items: tProp(typesRecord(typesUnchecked<any>()), () => ({})), // will be properly checked by types.objectMap(subType) }).$modelId
set $modelId(newId: ModelIdPropertyType<TProps, ModelIdPropertyName>): void
Parameters
- newId: ModelIdPropertyType<TProps, ModelIdPropertyName>
Returns void
Inherited from Model({ [modelIdKey]: idProp, items: tProp(typesRecord(typesUnchecked<any>()), () => ({})), // will be properly checked by types.objectMap(subType) }).$modelId

size

get size(): number
Returns number
the number of elements in the Map.

Implementation of Map.size

Methods

[iterator]

"[iterator]"(): MapIterator<[string, V]>
Returns MapIterator<[string, V]>
Implementation of Map.[iterator]

clear

clear(): void
Returns void
Implementation of Map.clear

delete

delete(key: string): boolean
Parameters
- key: string
Returns boolean
true if an element in the Map existed and has been removed, or false if the element does not exist.

Implementation of Map.delete

entries

entries(): MapIterator<[string, V]>
Returns an iterable of key, value pairs for every entry in the map.

Returns MapIterator<[string, V]>
Implementation of Map.entries

forEach

forEach(
callbackfn: (value: V, key: string, map: Map<string, V>) => void,
thisArg?: any,
): void
Executes a provided function once per each key/value pair in the Map, in insertion order.
Parameters
- callbackfn: (value: V, key: string, map: Map<string, V>) => void
- OptionalthisArg: any
Returns void
Implementation of Map.forEach

get

get(key: string): undefined | V
Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
Parameters
- key: string
Returns undefined | V
Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.

Implementation of Map.get

getRefId

getRefId(): undefined | string
Can be overridden to offer a reference id to be used in reference resolution. By default it will use the idProp if available or return undefined otherwise.

Returns undefined | string
Inherited from Model({ [modelIdKey]: idProp, items: tProp(typesRecord(typesUnchecked<any>()), () => ({})), // will be properly checked by types.objectMap(subType) }).getRefId

has

has(key: string): boolean
Parameters
- key: string
Returns boolean
boolean indicating whether an element with the specified key exists or not.

Implementation of Map.has

keys

keys(): MapIterator<string>
Returns an iterable of keys in the map

Returns MapIterator<string>
Implementation of Map.keys

set

set(key: string, value: V): this
Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
Parameters
- key: string
- value: V
Returns this
Implementation of Map.set

toString

toString(options?: { withData?: boolean }): string
Parameters
- Optionaloptions: { withData?: boolean }
Returns string
Inherited from Model({ [modelIdKey]: idProp, items: tProp(typesRecord(typesUnchecked<any>()), () => ({})), // will be properly checked by types.objectMap(subType) }).toString

typeCheck

typeCheck(): null | TypeCheckError
Performs a type check over the model instance. For this to work a data type has to be declared as part of the model properties.

Returns null | TypeCheckError
A TypeCheckError or null if there is no error.

Inherited from Model({ [modelIdKey]: idProp, items: tProp(typesRecord(typesUnchecked<any>()), () => ({})), // will be properly checked by types.objectMap(subType) }).typeCheck

values

values(): MapIterator<V>
Returns an iterable of values in the map

Returns MapIterator<V>
Implementation of Map.values

Class ObjectMap<V>

Type Parameters

Hierarchy

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns ObjectMap<V>

Properties

[fromSnapshotOverrideTypeSymbol]

[modelIdPropertyNameSymbol]

[propsTypeSymbol]

[toSnapshotOverrideTypeSymbol]

Readonly[toStringTag]

Readonly$

Readonly$modelType

items

Accessors

$modelId

Returns ModelIdPropertyType<TProps, ModelIdPropertyName>

Parameters

Returns void

size

Returns number

Methods

[iterator]

Returns MapIterator<[string, V]>

clear

Returns void

delete

Parameters

Returns boolean

entries

Returns MapIterator<[string, V]>

forEach

Parameters

Returns void

get

Parameters

Returns undefined | V

getRefId

Returns undefined | string

has

Parameters

Returns boolean

keys

Returns MapIterator<string>

set

Parameters

Returns this

toString

Parameters

Returns string

typeCheck

Returns null | TypeCheckError

values

Returns MapIterator<V>

Settings

On This Page

`Readonly`[toStringTag]

`Readonly`$

`Readonly`$modelType