@jbrowse/mobx-state-tree 5.6.10 → 5.7.1

package/esm/middlewares/on-action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-action.js","sourceRoot":"","sources":["../../src/middlewares/on-action.ts"],"names":[],"mappings":"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","sourcesContent":["import { runInAction } from \"mobx\"\n\nimport {\n  type AnyNode,\n  type IActionContext,\n  type IAnyStateTreeNode,\n  type IDisposer,\n  addMiddleware,\n  applyPatch,\n  applySnapshot,\n  asArray,\n  assertArg,\n  assertIsStateTreeNode,\n  devMode,\n  fail,\n  getRelativePathBetweenNodes,\n  getRunningActionContext,\n  getStateTreeNode,\n  getType,\n  isArray,\n  isPlainObject,\n  isPrimitive,\n  isProtected,\n  isRoot,\n  isStateTreeNode,\n  tryResolve,\n  warnError\n} from \"../internal.ts\"\n\nexport interface ISerializedActionCall {\n  name: string\n  path?: string\n  args?: any[]\n}\n\nexport interface IActionRecorder {\n  actions: ReadonlyArray<ISerializedActionCall>\n  readonly recording: boolean\n  stop(): void\n  resume(): void\n  replay(target: IAnyStateTreeNode): void\n}\n\nfunction serializeArgument(\n  node: AnyNode,\n  actionName: string,\n  index: number,\n  arg: any\n): any {\n  if (arg instanceof Date) {\n    return { $MST_DATE: arg.getTime() }\n  }\n  if (isPrimitive(arg)) {\n    return arg\n  }\n  // We should not serialize MST nodes, even if we can, because we don't know if the receiving party can handle a raw snapshot instead of an\n  // MST type instance. So if one wants to serialize a MST node that was pass in, either explitly pass: 1: an id, 2: a (relative) path, 3: a snapshot\n  if (isStateTreeNode(arg)) {\n    return serializeTheUnserializable(`[MSTNode: ${getType(arg).name}]`)\n  }\n  if (typeof arg === \"function\") {\n    return serializeTheUnserializable(`[function]`)\n  }\n  if (typeof arg === \"object\" && !isPlainObject(arg) && !isArray(arg)) {\n    return serializeTheUnserializable(\n      `[object ${\n        (arg && (arg as any).constructor && (arg as any).constructor.name) ||\n        \"Complex Object\"\n      }]`\n    )\n  }\n  try {\n    // Check if serializable, cycle free etc...\n    // MWE: there must be a better way....\n    JSON.stringify(arg) // or throws\n    return arg\n  } catch (e) {\n    return serializeTheUnserializable(\"\" + e)\n  }\n}\n\nfunction deserializeArgument(adm: AnyNode, value: any): any {\n  if (value && typeof value === \"object\" && \"$MST_DATE\" in value) {\n    return new Date(value[\"$MST_DATE\"])\n  }\n  return value\n}\n\nfunction serializeTheUnserializable(baseType: string) {\n  return {\n    $MST_UNSERIALIZABLE: true,\n    type: baseType\n  }\n}\n\n/**\n * Applies an action or a series of actions in a single MobX transaction.\n * Does not return any value\n * Takes an action description as produced by the `onAction` middleware.\n *\n * @param target\n * @param actions\n */\nexport function applyAction(\n  target: IAnyStateTreeNode,\n  actions: ISerializedActionCall | ISerializedActionCall[]\n): void {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertArg(actions, a => typeof a === \"object\", \"object or array\", 2)\n\n  runInAction(() => {\n    asArray(actions).forEach(action => baseApplyAction(target, action))\n  })\n}\n\nfunction baseApplyAction(\n  target: IAnyStateTreeNode,\n  action: ISerializedActionCall\n): any {\n  const resolvedTarget = tryResolve(target, action.path || \"\")\n  if (!resolvedTarget) {\n    throw fail(`Invalid action path: ${action.path || \"\"}`)\n  }\n  const node = getStateTreeNode(resolvedTarget)\n\n  // Reserved functions\n  if (action.name === \"@APPLY_PATCHES\") {\n    return applyPatch.call(null, resolvedTarget, action.args![0])\n  }\n  if (action.name === \"@APPLY_SNAPSHOT\") {\n    return applySnapshot.call(null, resolvedTarget, action.args![0])\n  }\n\n  if (!(typeof resolvedTarget[action.name] === \"function\")) {\n    throw fail(`Action '${action.name}' does not exist in '${node.path}'`)\n  }\n  return resolvedTarget[action.name](\n    ...(action.args ? action.args.map(v => deserializeArgument(node, v)) : [])\n  )\n}\n\n/**\n * Small abstraction around `onAction` and `applyAction`, attaches an action listener to a tree and records all the actions emitted.\n * Returns an recorder object with the following signature:\n *\n * Example:\n * ```ts\n * export interface IActionRecorder {\n *      // the recorded actions\n *      actions: ISerializedActionCall[]\n *      // true if currently recording\n *      recording: boolean\n *      // stop recording actions\n *      stop(): void\n *      // resume recording actions\n *      resume(): void\n *      // apply all the recorded actions on the given object\n *      replay(target: IAnyStateTreeNode): void\n * }\n * ```\n *\n * The optional filter function allows to skip recording certain actions.\n *\n * @param subject\n * @returns\n */\nexport function recordActions(\n  subject: IAnyStateTreeNode,\n  filter?: (\n    action: ISerializedActionCall,\n    actionContext: IActionContext | undefined\n  ) => boolean\n): IActionRecorder {\n  // check all arguments\n  assertIsStateTreeNode(subject, 1)\n\n  const actions: ISerializedActionCall[] = []\n  const listener = (call: ISerializedActionCall) => {\n    const recordThis = filter ? filter(call, getRunningActionContext()) : true\n    if (recordThis) {\n      actions.push(call)\n    }\n  }\n\n  let disposer: IDisposer | undefined\n  const recorder: IActionRecorder = {\n    actions,\n    get recording() {\n      return !!disposer\n    },\n    stop() {\n      if (disposer) {\n        disposer()\n        disposer = undefined\n      }\n    },\n    resume() {\n      if (disposer) {\n        return\n      }\n      disposer = onAction(subject, listener)\n    },\n    replay(target) {\n      applyAction(target, actions)\n    }\n  }\n\n  recorder.resume()\n  return recorder\n}\n\n/**\n * Registers a function that will be invoked for each action that is called on the provided model instance, or to any of its children.\n * See [actions](https://github.com/mobxjs/mobx-state-tree#actions) for more details. onAction events are emitted only for the outermost called action in the stack.\n * Action can also be intercepted by middleware using addMiddleware to change the function call before it will be run.\n *\n * Not all action arguments might be serializable. For unserializable arguments, a struct like `{ $MST_UNSERIALIZABLE: true, type: \"someType\" }` will be generated.\n * MST Nodes are considered non-serializable as well (they could be serialized as there snapshot, but it is uncertain whether an replaying party will be able to handle such a non-instantiated snapshot).\n * Rather, when using `onAction` middleware, one should consider in passing arguments which are 1: an id, 2: a (relative) path, or 3: a snapshot. Instead of a real MST node.\n *\n * Example:\n * ```ts\n * const Todo = types.model({\n *   task: types.string\n * })\n *\n * const TodoStore = types.model({\n *   todos: types.array(Todo)\n * }).actions(self => ({\n *   add(todo) {\n *     self.todos.push(todo);\n *   }\n * }))\n *\n * const s = TodoStore.create({ todos: [] })\n *\n * let disposer = onAction(s, (call) => {\n *   console.log(call);\n * })\n *\n * s.add({ task: \"Grab a coffee\" })\n * // Logs: { name: \"add\", path: \"\", args: [{ task: \"Grab a coffee\" }] }\n * ```\n *\n * @param target\n * @param listener\n * @param attachAfter (default false) fires the listener *after* the action has executed instead of before.\n * @returns\n */\nexport function onAction(\n  target: IAnyStateTreeNode,\n  listener: (call: ISerializedActionCall) => void,\n  attachAfter = false\n): IDisposer {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  if (devMode()) {\n    if (!isRoot(target)) {\n      warnError(\n        \"Warning: Attaching onAction listeners to non root nodes is dangerous: No events will be emitted for actions initiated higher up in the tree.\"\n      )\n    }\n    if (!isProtected(target)) {\n      warnError(\n        \"Warning: Attaching onAction listeners to non protected nodes is dangerous: No events will be emitted for direct modifications without action.\"\n      )\n    }\n  }\n\n  return addMiddleware(target, function handler(rawCall, next) {\n    if (rawCall.type === \"action\" && rawCall.id === rawCall.rootId) {\n      const sourceNode = getStateTreeNode(rawCall.context)\n      const info = {\n        name: rawCall.name,\n        path: getRelativePathBetweenNodes(getStateTreeNode(target), sourceNode),\n        args: rawCall.args.map((arg: any, index: number) =>\n          serializeArgument(sourceNode, rawCall.name, index, arg)\n        )\n      }\n      if (attachAfter) {\n        const res = next(rawCall)\n        listener(info)\n        return res\n      } else {\n        listener(info)\n        return next(rawCall)\n      }\n    } else {\n      return next(rawCall)\n    }\n  })\n}\n"]}

package/esm/types/complex-types/array.d.ts

@@ -0,0 +1,81 @@
+import { type IArrayDidChange, type IArraySplice, type IArrayWillChange, type IArrayWillSplice, type IObservableArray } from "mobx";
+import { ComplexType } from "../../core/type/type.ts";
+import { type AnyNode, type AnyObjectNode, type ExtractCSTWithSTN, type IAnyType, type IChildNodesMap, type IHooksGetter, type IJsonPatch, type IType, type IValidationContext, type IValidationResult, TypeFlags } from "../../internal.ts";
+/** @hidden */
+export interface IMSTArray<IT extends IAnyType> extends IObservableArray<IT["Type"]> {
+    push(...items: IT["Type"][]): number;
+    push(...items: ExtractCSTWithSTN<IT>[]): number;
+    concat(...items: ConcatArray<IT["Type"]>[]): IT["Type"][];
+    concat(...items: ConcatArray<ExtractCSTWithSTN<IT>>[]): IT["Type"][];
+    concat(...items: (IT["Type"] | ConcatArray<IT["Type"]>)[]): IT["Type"][];
+    concat(...items: (ExtractCSTWithSTN<IT> | ConcatArray<ExtractCSTWithSTN<IT>>)[]): IT["Type"][];
+    splice(start: number, deleteCount?: number): IT["Type"][];
+    splice(start: number, deleteCount: number, ...items: IT["Type"][]): IT["Type"][];
+    splice(start: number, deleteCount: number, ...items: ExtractCSTWithSTN<IT>[]): IT["Type"][];
+    unshift(...items: IT["Type"][]): number;
+    unshift(...items: ExtractCSTWithSTN<IT>[]): number;
+}
+/** @hidden */
+export interface IArrayType<IT extends IAnyType> extends IType<readonly IT["CreationType"][] | undefined, IT["SnapshotType"][], IMSTArray<IT>> {
+    hooks(hooks: IHooksGetter<IMSTArray<IAnyType>>): IArrayType<IT>;
+}
+/**
+ * @internal
+ * @hidden
+ */
+export declare class ArrayType<IT extends IAnyType> extends ComplexType<readonly IT["CreationType"][] | undefined, IT["SnapshotType"][], IMSTArray<IT>> {
+    private readonly _subType;
+    readonly flags = TypeFlags.Array;
+    private readonly hookInitializers;
+    constructor(name: string, _subType: IT, hookInitializers?: Array<IHooksGetter<IMSTArray<IT>>>);
+    hooks(hooks: IHooksGetter<IMSTArray<IT>>): ArrayType<IT>;
+    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: this["C"] | this["T"]): this["N"];
+    initializeChildNodes(objNode: this["N"], snapshot?: this["C"]): IChildNodesMap;
+    createNewInstance(childNodes: IChildNodesMap): this["T"];
+    finalizeNewInstance(node: this["N"], instance: this["T"]): void;
+    describe(): string;
+    getChildren(node: this["N"]): AnyNode[];
+    getChildNode(node: this["N"], key: string): AnyNode;
+    willChange(change: IArrayWillChange<AnyNode> | IArrayWillSplice<AnyNode>): IArrayWillChange<AnyNode> | IArrayWillSplice<AnyNode> | null;
+    getSnapshot(node: this["N"]): this["S"];
+    processInitialSnapshot(childNodes: IChildNodesMap): this["S"];
+    didChange(change: IArrayDidChange<AnyNode> | IArraySplice<AnyNode>): void;
+    applyPatchLocally(node: this["N"], subpath: string, patch: IJsonPatch): void;
+    applySnapshot(node: this["N"], snapshot: this["C"]): void;
+    getChildType(): IAnyType;
+    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
+    getDefaultSnapshot(): this["C"];
+    removeChild(node: this["N"], subpath: string): void;
+}
+/**
+ * `types.array` - Creates an index based collection type who's children are all of a uniform declared type.
+ *
+ * This type will always produce [observable arrays](https://mobx.js.org/api.html#observablearray)
+ *
+ * Example:
+ * ```ts
+ * const Todo = types.model({
+ *   task: types.string
+ * })
+ *
+ * const TodoStore = types.model({
+ *   todos: types.array(Todo)
+ * })
+ *
+ * const s = TodoStore.create({ todos: [] })
+ * unprotect(s) // needed to allow modifying outside of an action
+ * s.todos.push({ task: "Grab coffee" })
+ * console.log(s.todos[0]) // prints: "Grab coffee"
+ * ```
+ *
+ * @param subtype
+ * @returns
+ */
+export declare function array<IT extends IAnyType>(subtype: IT): IArrayType<IT>;
+/**
+ * Returns if a given value represents an array type.
+ *
+ * @param type
+ * @returns `true` if the type is an array type.
+ */
+export declare function isArrayType<Items extends IAnyType = IAnyType>(type: IAnyType): type is IArrayType<Items>;

package/esm/types/complex-types/array.js

@@ -0,0 +1,347 @@
+import { _getAdministration, action, intercept, observable, observe } from "mobx";
+import { ComplexType } from "../../core/type/type.js";
+import { EMPTY_ARRAY, EMPTY_OBJECT, ObjectNode, TypeFlags, addHiddenFinalProp, addHiddenWritableProp, assertIsType, convertChildNodesToArray, createActionInvoker, createObjectNode, devMode, fail, getContextForPath, getStateTreeNode, isArray, isNode, isPlainObject, isStateTreeNode, isType, mobxShallow, popContext, typeCheckFailure, typeCheckSuccess, typecheckInternal } from "../../internal.js";
+/**
+ * @internal
+ * @hidden
+ */
+export class ArrayType extends ComplexType {
+    _subType;
+    flags = TypeFlags.Array;
+    hookInitializers = [];
+    constructor(name, _subType, hookInitializers = []) {
+        super(name);
+        this._subType = _subType;
+        this.hookInitializers = hookInitializers;
+    }
+    hooks(hooks) {
+        const hookInitializers = this.hookInitializers.length > 0
+            ? this.hookInitializers.concat(hooks)
+            : [hooks];
+        return new ArrayType(this.name, this._subType, hookInitializers);
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        return createObjectNode(this, parent, subpath, environment, initialValue);
+    }
+    initializeChildNodes(objNode, snapshot = []) {
+        const subType = objNode.type._subType;
+        const result = {};
+        snapshot.forEach((item, index) => {
+            const subpath = "" + index;
+            result[subpath] = subType.instantiate(objNode, subpath, undefined, item);
+        });
+        return result;
+    }
+    createNewInstance(childNodes) {
+        const options = { ...mobxShallow, name: this.name };
+        return observable.array(convertChildNodesToArray(childNodes), options);
+    }
+    finalizeNewInstance(node, instance) {
+        _getAdministration(instance).dehancer = node.unbox;
+        const type = node.type;
+        type.hookInitializers.forEach(initializer => {
+            const hooks = initializer(instance);
+            Object.keys(hooks).forEach(name => {
+                const hook = hooks[name];
+                const actionInvoker = createActionInvoker(instance, name, hook);
+                (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(instance, name, actionInvoker);
+            });
+        });
+        intercept(instance, this.willChange);
+        observe(instance, this.didChange);
+    }
+    describe() {
+        return this.name;
+    }
+    getChildren(node) {
+        return node.storedValue.slice();
+    }
+    getChildNode(node, key) {
+        const index = Number(key);
+        if (index < node.storedValue.length) {
+            return node.storedValue[index];
+        }
+        throw fail("Not a child: " + key);
+    }
+    willChange(change) {
+        const node = getStateTreeNode(change.object);
+        node.assertWritable({ subpath: "" + change.index });
+        const subType = node.type._subType;
+        const childNodes = node.getChildren();
+        switch (change.type) {
+            case "update":
+                {
+                    if (change.newValue === change.object[change.index]) {
+                        return null;
+                    }
+                    const updatedNodes = reconcileArrayChildren(node, subType, [childNodes[change.index]], [change.newValue], [change.index]);
+                    if (!updatedNodes) {
+                        return null;
+                    }
+                    change.newValue = updatedNodes[0];
+                }
+                break;
+            case "splice":
+                {
+                    const { index, removedCount, added } = change;
+                    const addedNodes = reconcileArrayChildren(node, subType, childNodes.slice(index, index + removedCount), added, added.map((_, i) => index + i));
+                    if (!addedNodes) {
+                        return null;
+                    }
+                    change.added = addedNodes;
+                    // update paths of remaining items
+                    for (let i = index + removedCount; i < childNodes.length; i++) {
+                        childNodes[i].setParent(node, "" + (i + added.length - removedCount));
+                    }
+                }
+                break;
+        }
+        return change;
+    }
+    getSnapshot(node) {
+        return node.getChildren().map(childNode => childNode.snapshot);
+    }
+    processInitialSnapshot(childNodes) {
+        const processed = [];
+        Object.keys(childNodes).forEach(key => {
+            processed.push(childNodes[key].getSnapshot());
+        });
+        return processed;
+    }
+    didChange(change) {
+        const node = getStateTreeNode(change.object);
+        switch (change.type) {
+            case "update":
+                return void node.emitPatch({
+                    op: "replace",
+                    path: "" + change.index,
+                    value: change.newValue.snapshot,
+                    oldValue: change.oldValue ? change.oldValue.snapshot : undefined
+                }, node);
+            case "splice":
+                for (let i = change.removedCount - 1; i >= 0; i--) {
+                    node.emitPatch({
+                        op: "remove",
+                        path: "" + (change.index + i),
+                        oldValue: change.removed[i].snapshot
+                    }, node);
+                }
+                for (let i = 0; i < change.addedCount; i++) {
+                    node.emitPatch({
+                        op: "add",
+                        path: "" + (change.index + i),
+                        value: node.getChildNode("" + (change.index + i)).snapshot,
+                        oldValue: undefined
+                    }, node);
+                }
+                return;
+        }
+    }
+    applyPatchLocally(node, subpath, patch) {
+        const target = node.storedValue;
+        const index = subpath === "-" ? target.length : Number(subpath);
+        switch (patch.op) {
+            case "replace":
+                target[index] = patch.value;
+                break;
+            case "add":
+                target.splice(index, 0, patch.value);
+                break;
+            case "remove":
+                target.splice(index, 1);
+                break;
+        }
+    }
+    applySnapshot(node, snapshot) {
+        typecheckInternal(this, snapshot);
+        const target = node.storedValue;
+        target.replace(snapshot);
+    }
+    getChildType() {
+        return this._subType;
+    }
+    isValidSnapshot(value, context) {
+        if (!isArray(value)) {
+            return typeCheckFailure(context, value, "Value is not an array");
+        }
+        for (let i = 0; i < value.length; i++) {
+            getContextForPath(context, "" + i, this._subType);
+            const errors = this._subType.validate(value[i], context);
+            popContext(context);
+            if (errors.length > 0) {
+                return errors;
+            }
+        }
+        return typeCheckSuccess();
+    }
+    getDefaultSnapshot() {
+        return EMPTY_ARRAY;
+    }
+    removeChild(node, subpath) {
+        node.storedValue.splice(Number(subpath), 1);
+    }
+}
+ArrayType.prototype.applySnapshot = action(ArrayType.prototype.applySnapshot);
+/**
+ * `types.array` - Creates an index based collection type who's children are all of a uniform declared type.
+ *
+ * This type will always produce [observable arrays](https://mobx.js.org/api.html#observablearray)
+ *
+ * Example:
+ * ```ts
+ * const Todo = types.model({
+ *   task: types.string
+ * })
+ *
+ * const TodoStore = types.model({
+ *   todos: types.array(Todo)
+ * })
+ *
+ * const s = TodoStore.create({ todos: [] })
+ * unprotect(s) // needed to allow modifying outside of an action
+ * s.todos.push({ task: "Grab coffee" })
+ * console.log(s.todos[0]) // prints: "Grab coffee"
+ * ```
+ *
+ * @param subtype
+ * @returns
+ */
+export function array(subtype) {
+    assertIsType(subtype, 1);
+    return new ArrayType(`${subtype.name}[]`, subtype);
+}
+function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths) {
+    let nothingChanged = true;
+    for (let i = 0;; i++) {
+        const hasNewNode = i <= newValues.length - 1;
+        const oldNode = oldNodes[i];
+        let newValue = hasNewNode ? newValues[i] : undefined;
+        const newPath = "" + newPaths[i];
+        // for some reason, instead of newValue we got a node, fallback to the storedValue
+        // TODO: https://github.com/mobxjs/mobx-state-tree/issues/340#issuecomment-325581681
+        if (isNode(newValue)) {
+            newValue = newValue.storedValue;
+        }
+        if (!oldNode && !hasNewNode) {
+            // both are empty, end
+            break;
+        }
+        else if (!hasNewNode) {
+            // new one does not exists
+            nothingChanged = false;
+            oldNodes.splice(i, 1);
+            if (oldNode instanceof ObjectNode) {
+                // since it is going to be returned by pop/splice/shift better create it before killing it
+                // so it doesn't end up in an undead state
+                oldNode.createObservableInstanceIfNeeded();
+            }
+            oldNode.die();
+            i--;
+        }
+        else if (!oldNode) {
+            // there is no old node, create it
+            // check if already belongs to the same parent. if so, avoid pushing item in. only swapping can occur.
+            if (isStateTreeNode(newValue) &&
+                getStateTreeNode(newValue).parent === parent) {
+                // this node is owned by this parent, but not in the reconcilable set, so it must be double
+                throw fail(`Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '${parent.path}/${newPath}', but it lives already at '${getStateTreeNode(newValue).path}'`);
+            }
+            nothingChanged = false;
+            const newNode = valueAsNode(childType, parent, newPath, newValue);
+            oldNodes.splice(i, 0, newNode);
+        }
+        else if (areSame(oldNode, newValue)) {
+            // both are the same, reconcile
+            oldNodes[i] = valueAsNode(childType, parent, newPath, newValue, oldNode);
+        }
+        else {
+            // nothing to do, try to reorder
+            let oldMatch = undefined;
+            // find a possible candidate to reuse
+            for (let j = i; j < oldNodes.length; j++) {
+                if (areSame(oldNodes[j], newValue)) {
+                    oldMatch = oldNodes.splice(j, 1)[0];
+                    break;
+                }
+            }
+            nothingChanged = false;
+            const newNode = valueAsNode(childType, parent, newPath, newValue, oldMatch);
+            oldNodes.splice(i, 0, newNode);
+        }
+    }
+    return nothingChanged ? null : oldNodes;
+}
+/**
+ * Convert a value to a node at given parent and subpath. Attempts to reuse old node if possible and given.
+ */
+function valueAsNode(childType, parent, subpath, newValue, oldNode) {
+    // ensure the value is valid-ish
+    typecheckInternal(childType, newValue);
+    function getNewNode() {
+        // the new value has a MST node
+        if (isStateTreeNode(newValue)) {
+            const childNode = getStateTreeNode(newValue);
+            childNode.assertAlive(EMPTY_OBJECT);
+            // the node lives here
+            if (childNode.parent !== null && childNode.parent === parent) {
+                childNode.setParent(parent, subpath);
+                return childNode;
+            }
+        }
+        // there is old node and new one is a value/snapshot
+        if (oldNode) {
+            return childType.reconcile(oldNode, newValue, parent, subpath);
+        }
+        // nothing to do, create from scratch
+        return childType.instantiate(parent, subpath, undefined, newValue);
+    }
+    const newNode = getNewNode();
+    if (oldNode && oldNode !== newNode) {
+        if (oldNode instanceof ObjectNode) {
+            // since it is going to be returned by pop/splice/shift better create it before killing it
+            // so it doesn't end up in an undead state
+            oldNode.createObservableInstanceIfNeeded();
+        }
+        oldNode.die();
+    }
+    return newNode;
+}
+/**
+ * Check if a node holds a value.
+ */
+function areSame(oldNode, newValue) {
+    // never consider dead old nodes for reconciliation
+    if (!oldNode.isAlive) {
+        return false;
+    }
+    // the new value has the same node
+    if (isStateTreeNode(newValue)) {
+        const newNode = getStateTreeNode(newValue);
+        return newNode.isAlive && newNode === oldNode;
+    }
+    // the provided value is the snapshot of the old node
+    if (oldNode.snapshot === newValue) {
+        return true;
+    }
+    // Non object nodes don't get reconciled
+    if (!(oldNode instanceof ObjectNode)) {
+        return false;
+    }
+    const oldNodeType = oldNode.getReconciliationType();
+    // new value is a snapshot with the correct identifier
+    return (oldNode.identifier !== null &&
+        oldNode.identifierAttribute &&
+        isPlainObject(newValue) &&
+        oldNodeType.is(newValue) &&
+        oldNodeType.isMatchingSnapshotId(oldNode, newValue));
+}
+/**
+ * Returns if a given value represents an array type.
+ *
+ * @param type
+ * @returns `true` if the type is an array type.
+ */
+export function isArrayType(type) {
+    return isType(type) && (type.flags & TypeFlags.Array) > 0;
+}
+//# sourceMappingURL=array.js.map

package/esm/types/complex-types/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","sourceRoot":"","sources":["../../../src/types/complex-types/array.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type IArrayDidChange,\n  type IArraySplice,\n  type IArrayWillChange,\n  type IArrayWillSplice,\n  type IObservableArray,\n  _getAdministration,\n  action,\n  intercept,\n  observable,\n  observe\n} from \"mobx\"\n\nimport { ComplexType } from \"../../core/type/type.ts\"\nimport {\n  type AnyNode,\n  type AnyObjectNode,\n  EMPTY_ARRAY,\n  EMPTY_OBJECT,\n  type ExtractCSTWithSTN,\n  type IAnyStateTreeNode,\n  type IAnyType,\n  type IChildNodesMap,\n  type IHooksGetter,\n  type IJsonPatch,\n  type IStateTreeNode,\n  type IType,\n  type IValidationContext,\n  type IValidationResult,\n  ObjectNode,\n  TypeFlags,\n  addHiddenFinalProp,\n  addHiddenWritableProp,\n  assertIsType,\n  convertChildNodesToArray,\n  createActionInvoker,\n  createObjectNode,\n  devMode,\n  fail,\n  getContextForPath,\n  getStateTreeNode,\n  isArray,\n  isNode,\n  isPlainObject,\n  isStateTreeNode,\n  isType,\n  mobxShallow,\n  popContext,\n  typeCheckFailure,\n  typeCheckSuccess,\n  typecheckInternal\n} from \"../../internal.ts\"\n\n/** @hidden */\nexport interface IMSTArray<IT extends IAnyType> extends IObservableArray<\n  IT[\"Type\"]\n> {\n  // needs to be split or else it will complain about not being compatible with the array interface\n  push(...items: IT[\"Type\"][]): number\n  push(...items: ExtractCSTWithSTN<IT>[]): number\n\n  concat(...items: ConcatArray<IT[\"Type\"]>[]): IT[\"Type\"][]\n  concat(...items: ConcatArray<ExtractCSTWithSTN<IT>>[]): IT[\"Type\"][]\n\n  concat(...items: (IT[\"Type\"] | ConcatArray<IT[\"Type\"]>)[]): IT[\"Type\"][]\n  concat(\n    ...items: (ExtractCSTWithSTN<IT> | ConcatArray<ExtractCSTWithSTN<IT>>)[]\n  ): IT[\"Type\"][]\n\n  splice(start: number, deleteCount?: number): IT[\"Type\"][]\n  splice(\n    start: number,\n    deleteCount: number,\n    ...items: IT[\"Type\"][]\n  ): IT[\"Type\"][]\n  splice(\n    start: number,\n    deleteCount: number,\n    ...items: ExtractCSTWithSTN<IT>[]\n  ): IT[\"Type\"][]\n\n  unshift(...items: IT[\"Type\"][]): number\n  unshift(...items: ExtractCSTWithSTN<IT>[]): number\n}\n\n/** @hidden */\nexport interface IArrayType<IT extends IAnyType> extends IType<\n  readonly IT[\"CreationType\"][] | undefined,\n  IT[\"SnapshotType\"][],\n  IMSTArray<IT>\n> {\n  hooks(hooks: IHooksGetter<IMSTArray<IAnyType>>): IArrayType<IT>\n}\n\n/**\n * @internal\n * @hidden\n */\nexport class ArrayType<IT extends IAnyType> extends ComplexType<\n  readonly IT[\"CreationType\"][] | undefined,\n  IT[\"SnapshotType\"][],\n  IMSTArray<IT>\n> {\n  readonly flags = TypeFlags.Array\n  private readonly hookInitializers: Array<IHooksGetter<IMSTArray<IT>>> = []\n  constructor(\n    name: string,\n    private readonly _subType: IT,\n    hookInitializers: Array<IHooksGetter<IMSTArray<IT>>> = []\n  ) {\n    super(name)\n    this.hookInitializers = hookInitializers\n  }\n\n  hooks(hooks: IHooksGetter<IMSTArray<IT>>) {\n    const hookInitializers =\n      this.hookInitializers.length > 0\n        ? this.hookInitializers.concat(hooks)\n        : [hooks]\n    return new ArrayType(this.name, this._subType, hookInitializers)\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: this[\"C\"] | this[\"T\"]\n  ): this[\"N\"] {\n    return createObjectNode(this, parent, subpath, environment, initialValue)\n  }\n\n  initializeChildNodes(\n    objNode: this[\"N\"],\n    snapshot: this[\"C\"] = []\n  ): IChildNodesMap {\n    const subType = (objNode.type as this)._subType\n    const result: IChildNodesMap = {}\n    snapshot.forEach((item, index) => {\n      const subpath = \"\" + index\n      result[subpath] = subType.instantiate(objNode, subpath, undefined, item)\n    })\n    return result\n  }\n\n  createNewInstance(childNodes: IChildNodesMap): this[\"T\"] {\n    const options = { ...mobxShallow, name: this.name }\n    return observable.array(\n      convertChildNodesToArray(childNodes),\n      options\n    ) as this[\"T\"]\n  }\n\n  finalizeNewInstance(node: this[\"N\"], instance: this[\"T\"]): void {\n    _getAdministration(instance).dehancer = node.unbox\n\n    const type = node.type as this\n    type.hookInitializers.forEach(initializer => {\n      const hooks = initializer(instance)\n      Object.keys(hooks).forEach(name => {\n        const hook = hooks[name as keyof typeof hooks]!\n        const actionInvoker = createActionInvoker(\n          instance as IAnyStateTreeNode,\n          name,\n          hook\n        )\n        ;(!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(\n          instance,\n          name,\n          actionInvoker\n        )\n      })\n    })\n\n    intercept(instance as IObservableArray<AnyNode>, this.willChange)\n    observe(instance as IObservableArray<AnyNode>, this.didChange)\n  }\n\n  describe() {\n    return this.name\n  }\n\n  getChildren(node: this[\"N\"]): AnyNode[] {\n    return node.storedValue.slice()\n  }\n\n  getChildNode(node: this[\"N\"], key: string): AnyNode {\n    const index = Number(key)\n    if (index < node.storedValue.length) {\n      return node.storedValue[index]\n    }\n    throw fail(\"Not a child: \" + key)\n  }\n\n  willChange(\n    change: IArrayWillChange<AnyNode> | IArrayWillSplice<AnyNode>\n  ): IArrayWillChange<AnyNode> | IArrayWillSplice<AnyNode> | null {\n    const node = getStateTreeNode(change.object as IStateTreeNode<this>)\n    node.assertWritable({ subpath: \"\" + change.index })\n    const subType = (node.type as this)._subType\n    const childNodes = node.getChildren()\n\n    switch (change.type) {\n      case \"update\":\n        {\n          if (change.newValue === change.object[change.index]) {\n            return null\n          }\n\n          const updatedNodes = reconcileArrayChildren(\n            node,\n            subType,\n            [childNodes[change.index]],\n            [change.newValue],\n            [change.index]\n          )\n          if (!updatedNodes) {\n            return null\n          }\n          change.newValue = updatedNodes[0]\n        }\n        break\n      case \"splice\":\n        {\n          const { index, removedCount, added } = change\n\n          const addedNodes = reconcileArrayChildren(\n            node,\n            subType,\n            childNodes.slice(index, index + removedCount),\n            added,\n            added.map((_, i) => index + i)\n          )\n          if (!addedNodes) {\n            return null\n          }\n          change.added = addedNodes\n\n          // update paths of remaining items\n          for (let i = index + removedCount; i < childNodes.length; i++) {\n            childNodes[i].setParent(\n              node,\n              \"\" + (i + added.length - removedCount)\n            )\n          }\n        }\n        break\n    }\n    return change\n  }\n\n  getSnapshot(node: this[\"N\"]): this[\"S\"] {\n    return node.getChildren().map(childNode => childNode.snapshot)\n  }\n\n  processInitialSnapshot(childNodes: IChildNodesMap): this[\"S\"] {\n    const processed: this[\"S\"] = []\n    Object.keys(childNodes).forEach(key => {\n      processed.push(childNodes[key].getSnapshot())\n    })\n    return processed\n  }\n\n  didChange(change: IArrayDidChange<AnyNode> | IArraySplice<AnyNode>): void {\n    const node = getStateTreeNode(change.object as IAnyStateTreeNode)\n    switch (change.type) {\n      case \"update\":\n        return void node.emitPatch(\n          {\n            op: \"replace\",\n            path: \"\" + change.index,\n            value: change.newValue.snapshot,\n            oldValue: change.oldValue ? change.oldValue.snapshot : undefined\n          },\n          node\n        )\n      case \"splice\":\n        for (let i = change.removedCount - 1; i >= 0; i--) {\n          node.emitPatch(\n            {\n              op: \"remove\",\n              path: \"\" + (change.index + i),\n              oldValue: change.removed[i].snapshot\n            },\n            node\n          )\n        }\n        for (let i = 0; i < change.addedCount; i++) {\n          node.emitPatch(\n            {\n              op: \"add\",\n              path: \"\" + (change.index + i),\n              value: node.getChildNode(\"\" + (change.index + i)).snapshot,\n              oldValue: undefined\n            },\n            node\n          )\n        }\n        return\n    }\n  }\n\n  applyPatchLocally(node: this[\"N\"], subpath: string, patch: IJsonPatch): void {\n    const target = node.storedValue\n    const index = subpath === \"-\" ? target.length : Number(subpath)\n    switch (patch.op) {\n      case \"replace\":\n        target[index] = patch.value\n        break\n      case \"add\":\n        target.splice(index, 0, patch.value)\n        break\n      case \"remove\":\n        target.splice(index, 1)\n        break\n    }\n  }\n\n  applySnapshot(node: this[\"N\"], snapshot: this[\"C\"]): void {\n    typecheckInternal(this, snapshot)\n    const target = node.storedValue\n    target.replace(snapshot as any)\n  }\n\n  getChildType(): IAnyType {\n    return this._subType\n  }\n\n  isValidSnapshot(\n    value: this[\"C\"],\n    context: IValidationContext\n  ): IValidationResult {\n    if (!isArray(value)) {\n      return typeCheckFailure(context, value, \"Value is not an array\")\n    }\n\n    for (let i = 0; i < value.length; i++) {\n      getContextForPath(context, \"\" + i, this._subType)\n      const errors = this._subType.validate(value[i], context)\n      popContext(context)\n      if (errors.length > 0) {\n        return errors\n      }\n    }\n    return typeCheckSuccess()\n  }\n\n  getDefaultSnapshot(): this[\"C\"] {\n    return EMPTY_ARRAY as this[\"C\"]\n  }\n\n  removeChild(node: this[\"N\"], subpath: string) {\n    node.storedValue.splice(Number(subpath), 1)\n  }\n}\nArrayType.prototype.applySnapshot = action(ArrayType.prototype.applySnapshot)\n\n/**\n * `types.array` - Creates an index based collection type who's children are all of a uniform declared type.\n *\n * This type will always produce [observable arrays](https://mobx.js.org/api.html#observablearray)\n *\n * Example:\n * ```ts\n * const Todo = types.model({\n *   task: types.string\n * })\n *\n * const TodoStore = types.model({\n *   todos: types.array(Todo)\n * })\n *\n * const s = TodoStore.create({ todos: [] })\n * unprotect(s) // needed to allow modifying outside of an action\n * s.todos.push({ task: \"Grab coffee\" })\n * console.log(s.todos[0]) // prints: \"Grab coffee\"\n * ```\n *\n * @param subtype\n * @returns\n */\nexport function array<IT extends IAnyType>(subtype: IT): IArrayType<IT> {\n  assertIsType(subtype, 1)\n  return new ArrayType<IT>(`${subtype.name}[]`, subtype)\n}\n\nfunction reconcileArrayChildren<TT>(\n  parent: AnyObjectNode,\n  childType: IType<any, any, TT>,\n  oldNodes: AnyNode[],\n  newValues: TT[],\n  newPaths: (string | number)[]\n): AnyNode[] | null {\n  let nothingChanged = true\n\n  for (let i = 0; ; i++) {\n    const hasNewNode = i <= newValues.length - 1\n    const oldNode = oldNodes[i]\n    let newValue = hasNewNode ? newValues[i] : undefined\n    const newPath = \"\" + newPaths[i]\n\n    // for some reason, instead of newValue we got a node, fallback to the storedValue\n    // TODO: https://github.com/mobxjs/mobx-state-tree/issues/340#issuecomment-325581681\n    if (isNode(newValue)) {\n      newValue = newValue.storedValue\n    }\n\n    if (!oldNode && !hasNewNode) {\n      // both are empty, end\n      break\n    } else if (!hasNewNode) {\n      // new one does not exists\n      nothingChanged = false\n      oldNodes.splice(i, 1)\n      if (oldNode instanceof ObjectNode) {\n        // since it is going to be returned by pop/splice/shift better create it before killing it\n        // so it doesn't end up in an undead state\n        oldNode.createObservableInstanceIfNeeded()\n      }\n      oldNode.die()\n      i--\n    } else if (!oldNode) {\n      // there is no old node, create it\n      // check if already belongs to the same parent. if so, avoid pushing item in. only swapping can occur.\n      if (\n        isStateTreeNode(newValue) &&\n        getStateTreeNode(newValue).parent === parent\n      ) {\n        // this node is owned by this parent, but not in the reconcilable set, so it must be double\n        throw fail(\n          `Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '${\n            parent.path\n          }/${newPath}', but it lives already at '${getStateTreeNode(newValue).path}'`\n        )\n      }\n      nothingChanged = false\n      const newNode = valueAsNode(childType, parent, newPath, newValue)\n      oldNodes.splice(i, 0, newNode)\n    } else if (areSame(oldNode, newValue)) {\n      // both are the same, reconcile\n      oldNodes[i] = valueAsNode(childType, parent, newPath, newValue, oldNode)\n    } else {\n      // nothing to do, try to reorder\n      let oldMatch = undefined\n\n      // find a possible candidate to reuse\n      for (let j = i; j < oldNodes.length; j++) {\n        if (areSame(oldNodes[j], newValue)) {\n          oldMatch = oldNodes.splice(j, 1)[0]\n          break\n        }\n      }\n\n      nothingChanged = false\n      const newNode = valueAsNode(\n        childType,\n        parent,\n        newPath,\n        newValue,\n        oldMatch\n      )\n      oldNodes.splice(i, 0, newNode)\n    }\n  }\n\n  return nothingChanged ? null : oldNodes\n}\n\n/**\n * Convert a value to a node at given parent and subpath. Attempts to reuse old node if possible and given.\n */\nfunction valueAsNode(\n  childType: IAnyType,\n  parent: AnyObjectNode,\n  subpath: string,\n  newValue: any,\n  oldNode?: AnyNode\n) {\n  // ensure the value is valid-ish\n  typecheckInternal(childType, newValue)\n\n  function getNewNode() {\n    // the new value has a MST node\n    if (isStateTreeNode(newValue)) {\n      const childNode = getStateTreeNode(newValue)\n      childNode.assertAlive(EMPTY_OBJECT)\n\n      // the node lives here\n      if (childNode.parent !== null && childNode.parent === parent) {\n        childNode.setParent(parent, subpath)\n        return childNode\n      }\n    }\n    // there is old node and new one is a value/snapshot\n    if (oldNode) {\n      return childType.reconcile(oldNode, newValue, parent, subpath)\n    }\n\n    // nothing to do, create from scratch\n    return childType.instantiate(parent, subpath, undefined, newValue)\n  }\n\n  const newNode = getNewNode()\n  if (oldNode && oldNode !== newNode) {\n    if (oldNode instanceof ObjectNode) {\n      // since it is going to be returned by pop/splice/shift better create it before killing it\n      // so it doesn't end up in an undead state\n      oldNode.createObservableInstanceIfNeeded()\n    }\n    oldNode.die()\n  }\n  return newNode\n}\n\n/**\n * Check if a node holds a value.\n */\nfunction areSame(oldNode: AnyNode, newValue: any) {\n  // never consider dead old nodes for reconciliation\n  if (!oldNode.isAlive) {\n    return false\n  }\n\n  // the new value has the same node\n  if (isStateTreeNode(newValue)) {\n    const newNode = getStateTreeNode(newValue)\n    return newNode.isAlive && newNode === oldNode\n  }\n\n  // the provided value is the snapshot of the old node\n  if (oldNode.snapshot === newValue) {\n    return true\n  }\n\n  // Non object nodes don't get reconciled\n  if (!(oldNode instanceof ObjectNode)) {\n    return false\n  }\n\n  const oldNodeType = oldNode.getReconciliationType()\n  // new value is a snapshot with the correct identifier\n  return (\n    oldNode.identifier !== null &&\n    oldNode.identifierAttribute &&\n    isPlainObject(newValue) &&\n    oldNodeType.is(newValue) &&\n    (oldNodeType as any).isMatchingSnapshotId(oldNode, newValue)\n  )\n}\n\n/**\n * Returns if a given value represents an array type.\n *\n * @param type\n * @returns `true` if the type is an array type.\n */\nexport function isArrayType<Items extends IAnyType = IAnyType>(\n  type: IAnyType\n): type is IArrayType<Items> {\n  return isType(type) && (type.flags & TypeFlags.Array) > 0\n}\n"]}

package/esm/types/complex-types/map.d.ts

@@ -0,0 +1,111 @@
+import { type IInterceptor, type IKeyValueMap, type IMapDidChange, type IMapWillChange, type Lambda, ObservableMap } from "mobx";
+import { ComplexType } from "../../core/type/type.ts";
+import { type AnyNode, type AnyObjectNode, type ExtractCSTWithSTN, type IAnyType, type IChildNodesMap, type IHooksGetter, type IJsonPatch, type IType, type IValidationContext, type IValidationResult, TypeFlags } from "../../internal.ts";
+/** @hidden */
+export interface IMapType<IT extends IAnyType> extends IType<IKeyValueMap<IT["CreationType"]> | undefined, IKeyValueMap<IT["SnapshotType"]>, IMSTMap<IT>> {
+    hooks(hooks: IHooksGetter<IMSTMap<IT>>): IMapType<IT>;
+}
+/** @hidden */
+export interface IMSTMap<IT extends IAnyType> {
+    clear(): void;
+    delete(key: string): boolean;
+    forEach(callbackfn: (value: IT["Type"], key: string | number, map: this) => void, thisArg?: any): void;
+    get(key: string | number): IT["Type"] | undefined;
+    has(key: string | number): boolean;
+    set(key: string | number, value: ExtractCSTWithSTN<IT>): this;
+    readonly size: number;
+    put(value: ExtractCSTWithSTN<IT>): IT["Type"];
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<IT["Type"]>;
+    entries(): IterableIterator<[string, IT["Type"]]>;
+    [Symbol.iterator](): IterableIterator<[string, IT["Type"]]>;
+    /** Merge another object into this map, returns self. */
+    merge(other: IMSTMap<IType<any, any, IT["TypeWithoutSTN"]>> | IKeyValueMap<ExtractCSTWithSTN<IT>> | any): this;
+    replace(values: IMSTMap<IType<any, any, IT["TypeWithoutSTN"]>> | IKeyValueMap<ExtractCSTWithSTN<IT>> | any): this;
+    toJSON(): IKeyValueMap<IT["SnapshotType"]>;
+    toString(): string;
+    [Symbol.toStringTag]: "Map";
+    /**
+     * Observes this object. Triggers for the events 'add', 'update' and 'delete'.
+     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
+     * for callback details
+     */
+    observe(listener: (changes: IMapDidChange<string, IT["Type"]>) => void, fireImmediately?: boolean): Lambda;
+    intercept(handler: IInterceptor<IMapWillChange<string, IT["Type"]>>): Lambda;
+}
+/**
+ * @internal
+ * @hidden
+ */
+export declare enum MapIdentifierMode {
+    UNKNOWN = 0,
+    YES = 1,
+    NO = 2
+}
+/**
+ * @internal
+ * @hidden
+ */
+export declare class MapType<IT extends IAnyType> extends ComplexType<IKeyValueMap<IT["CreationType"]> | undefined, IKeyValueMap<IT["SnapshotType"]>, IMSTMap<IT>> {
+    private readonly _subType;
+    identifierMode: MapIdentifierMode;
+    mapIdentifierAttribute: string | undefined;
+    readonly flags = TypeFlags.Map;
+    private readonly hookInitializers;
+    constructor(name: string, _subType: IAnyType, hookInitializers?: Array<IHooksGetter<IMSTMap<IT>>>);
+    hooks(hooks: IHooksGetter<IMSTMap<IT>>): MapType<IT>;
+    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: this["C"] | this["T"]): this["N"];
+    private _determineIdentifierMode;
+    initializeChildNodes(objNode: this["N"], initialSnapshot?: this["C"]): IChildNodesMap;
+    createNewInstance(childNodes: IChildNodesMap): this["T"];
+    finalizeNewInstance(node: this["N"], instance: ObservableMap<string, any>): void;
+    describe(): string;
+    getChildren(node: this["N"]): ReadonlyArray<AnyNode>;
+    getChildNode(node: this["N"], key: string): AnyNode;
+    willChange(change: IMapWillChange<string, AnyNode>): IMapWillChange<string, AnyNode> | null;
+    private processIdentifier;
+    getSnapshot(node: this["N"]): this["S"];
+    processInitialSnapshot(childNodes: IChildNodesMap): this["S"];
+    didChange(change: IMapDidChange<string, AnyNode>): void;
+    applyPatchLocally(node: this["N"], subpath: string, patch: IJsonPatch): void;
+    applySnapshot(node: this["N"], snapshot: this["C"]): void;
+    getChildType(): IAnyType;
+    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
+    getDefaultSnapshot(): this["C"];
+    removeChild(node: this["N"], subpath: string): void;
+}
+/**
+ * `types.map` - Creates a key based collection type who's children are all of a uniform declared type.
+ * If the type stored in a map has an identifier, it is mandatory to store the child under that identifier in the map.
+ *
+ * This type will always produce [observable maps](https://mobx.js.org/api.html#observablemap)
+ *
+ * Example:
+ * ```ts
+ * const Todo = types.model({
+ *   id: types.identifier,
+ *   task: types.string
+ * })
+ *
+ * const TodoStore = types.model({
+ *   todos: types.map(Todo)
+ * })
+ *
+ * const s = TodoStore.create({ todos: {} })
+ * unprotect(s)
+ * s.todos.set(17, { task: "Grab coffee", id: 17 })
+ * s.todos.put({ task: "Grab cookie", id: 18 }) // put will infer key from the identifier
+ * console.log(s.todos.get(17).task) // prints: "Grab coffee"
+ * ```
+ *
+ * @param subtype
+ * @returns
+ */
+export declare function map<IT extends IAnyType>(subtype: IT): IMapType<IT>;
+/**
+ * Returns if a given value represents a map type.
+ *
+ * @param type
+ * @returns `true` if it is a map type.
+ */
+export declare function isMapType<Items extends IAnyType = IAnyType>(type: IAnyType): type is IMapType<Items>;