Class ObjectMap<V>

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

Type Parameters

  • V

Hierarchy

  • BaseModel<{
        $modelId: ModelIdProp<string> & {
            typedAs<T>(): ModelIdProp<T>;
        };
        items: OptionalModelProp<{
            [k: string]: TypeToData<S> extends infer R
                ? R
                : never;
        }>;
    }, never, never, "$modelId", this> & Omit<{
        $modelId: string;
        items: {
            [k: string]: TypeToData<S> extends infer R
                ? R
                : never;
        };
    }, BaseModelKeys> & {}
    • ObjectMap

Implements

  • Map<string, V>

Constructors

constructor

Properties

[fromSnapshotOverrideTypeSymbol] [modelIdPropertyNameSymbol] [propsTypeSymbol] [toSnapshotOverrideTypeSymbol] [toStringTag] $ $modelType items

Accessors

$modelId size

Methods

[iterator] clear delete entries forEach get getRefId has keys set toString typeCheck values

Constructors

constructor

  • new ObjectMap<V>(data): ObjectMap<V>

  • Type Parameters

    • V

    Parameters

    Returns ObjectMap<V>

Properties

[fromSnapshotOverrideTypeSymbol]

[fromSnapshotOverrideTypeSymbol]: never

[modelIdPropertyNameSymbol]

[modelIdPropertyNameSymbol]

[propsTypeSymbol]

[propsTypeSymbol]: {
    $modelId: ModelIdProp<string> & {
        typedAs<T>(): ModelIdProp<T>;
    };
    items: OptionalModelProp<{
        [k: string]: TypeToData<S> extends infer R
            ? R
            : never;
    }>;
}

[toSnapshotOverrideTypeSymbol]

[toSnapshotOverrideTypeSymbol]: never

Readonly[toStringTag]

[toStringTag] = "ObjectMap"

Readonly$

$: {
    $modelId: string;
    items: {
        [k: string]: TypeToData<S> extends infer R
            ? R
            : never;
    };
}

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]: TypeToData<S> extends infer R
        ? R
        : never;
} = ...

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>

  • set $modelId(newId): void

  • Parameters

    Returns void

size

  • get size(): number

  • Returns number

    the number of elements in the Map.

Methods

[iterator]

  • [iterator](): MapIterator<[string, V]>

  • Returns MapIterator<[string, V]>

clear

  • clear(): void

  • Returns void

delete

  • delete(key): 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.

entries

  • entries(): MapIterator<[string, V]>

  • Returns an iterable of key, value pairs for every entry in the map.

    Returns MapIterator<[string, V]>

forEach

  • forEach(callbackfn, thisArg?): 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)
        • (value, key, map): void

        • Parameters

          • value: V
          • key: string
          • map: Map<string, V>

          Returns void

    • OptionalthisArg: any

    Returns void

get

  • get(key): 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.

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

has

  • has(key): boolean

  • Parameters

    • key: string

    Returns boolean

    boolean indicating whether an element with the specified key exists or not.

keys

  • keys(): MapIterator<string>

  • Returns an iterable of keys in the map

    Returns MapIterator<string>

set

  • set(key, value): 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

toString

  • toString(options?): string

  • Parameters

    • Optionaloptions: {
          withData?: boolean;
      }
      • OptionalwithData?: boolean

    Returns string

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.

values

  • values(): MapIterator<V>

  • Returns an iterable of values in the map

    Returns MapIterator<V>

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods