@jbrowse/mobx-state-tree 5.7.0 → 5.8.6

package/esm/core/type/type.d.ts

@@ -1,317 +0,0 @@
-import { BaseNode } from "../../internal.ts";
-import type { AnyNode, AnyObjectNode, IChildNodesMap, IJsonPatch, IStateTreeNode, IValidationContext, IValidationResult, ModelPrimitive, ObjectNode, ScalarNode } from "../../internal.ts";
-/**
- * @internal
- * @hidden
- */
-export declare enum TypeFlags {
-    String = 1,
-    Number = 2,
-    Boolean = 4,
-    Date = 8,
-    Literal = 16,
-    Array = 32,
-    Map = 64,
-    Object = 128,
-    Frozen = 256,
-    Optional = 512,
-    Reference = 1024,
-    Identifier = 2048,
-    Late = 4096,
-    Refinement = 8192,
-    Union = 16384,
-    Null = 32768,
-    Undefined = 65536,
-    Integer = 131072,
-    Custom = 262144,
-    SnapshotProcessor = 524288,
-    Lazy = 1048576,
-    Finite = 2097152,
-    Float = 4194304
-}
-/**
- * @internal
- * @hidden
- */
-export declare const cannotDetermineSubtype = "cannotDetermine";
-/**
- * A state tree node value.
- * @hidden
- */
-export type STNValue<T, IT extends IAnyType> = T extends object ? T & IStateTreeNode<IT> : T;
-/** @hidden */
-declare const $type: unique symbol;
-/**
- * A type, either complex or simple.
- */
-export interface IType<C, S, T> {
-    /** @hidden */
-    readonly [$type]: undefined;
-    /**
-     * Friendly type name.
-     */
-    name: string;
-    /**
-     * Name of the identifier attribute or null if none.
-     */
-    readonly identifierAttribute?: string;
-    /**
-     * Creates an instance for the type given an snapshot input.
-     *
-     * @returns An instance of that type.
-     */
-    create(snapshot?: C, env?: any): this["Type"];
-    /**
-     * Checks if a given snapshot / instance is of the given type.
-     *
-     * @param thing Snapshot or instance to be checked.
-     * @returns true if the value is of the current type, false otherwise.
-     */
-    is(thing: any): thing is C | this["Type"];
-    /**
-     * Run's the type's typechecker on the given value with the given validation context.
-     *
-     * @param thing Value to be checked, either a snapshot or an instance.
-     * @param context Validation context, an array of { subpaths, subtypes } that should be validated
-     * @returns The validation result, an array with the list of validation errors.
-     */
-    validate(thing: C, context: IValidationContext): IValidationResult;
-    /**
-     * Gets the textual representation of the type as a string.
-     */
-    describe(): string;
-    /**
-     * @deprecated use `Instance<typeof MyType>` instead.
-     * @hidden
-     */
-    readonly Type: STNValue<T, this>;
-    /**
-     * @deprecated do not use.
-     * @hidden
-     */
-    readonly TypeWithoutSTN: T;
-    /**
-     * @deprecated use `SnapshotOut<typeof MyType>` instead.
-     * @hidden
-     */
-    readonly SnapshotType: S;
-    /**
-     * @deprecated use `SnapshotIn<typeof MyType>` instead.
-     * @hidden
-     */
-    readonly CreationType: C;
-    /**
-     * @internal
-     * @hidden
-     */
-    flags: TypeFlags;
-    /**
-     * @internal
-     * @hidden
-     */
-    isType: true;
-    /**
-     * @internal
-     * @hidden
-     */
-    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: C | T): BaseNode<C, S, T>;
-    /**
-     * @internal
-     * @hidden
-     */
-    reconcile(current: BaseNode<C, S, T>, newValue: C | T, parent: AnyObjectNode, subpath: string): BaseNode<C, S, T>;
-    /**
-     * @internal
-     * @hidden
-     */
-    getSnapshot(node: BaseNode<C, S, T>, applyPostProcess?: boolean): S;
-    /**
-     * @internal
-     * @hidden
-     */
-    isAssignableFrom(type: IAnyType): boolean;
-    /**
-     * @internal
-     * @hidden
-     */
-    getSubTypes(): IAnyType[] | IAnyType | null | typeof cannotDetermineSubtype;
-}
-/**
- * Any kind of type.
- */
-export interface IAnyType extends IType<any, any, any> {
-}
-/**
- * A simple type, this is, a type where the instance and the snapshot representation are the same.
- */
-export interface ISimpleType<T> extends IType<T, T, T> {
-}
-/** @hidden */
-export type Primitives = ModelPrimitive | null | undefined;
-/**
- * A complex type.
- * @deprecated just for compatibility with old versions, could be deprecated on the next major version
- * @hidden
- */
-export interface IComplexType<C, S, T> extends IType<C, S, T & object> {
-}
-/**
- * Any kind of complex type.
- */
-export interface IAnyComplexType extends IType<any, any, object> {
-}
-/** @hidden */
-export type ExtractCSTWithoutSTN<IT extends {
-    [$type]: undefined;
-    CreationType: any;
-    SnapshotType: any;
-    TypeWithoutSTN: any;
-}> = IT["CreationType"] | IT["SnapshotType"] | IT["TypeWithoutSTN"];
-/** @hidden */
-export type ExtractCSTWithSTN<IT extends {
-    [$type]: undefined;
-    CreationType: any;
-    SnapshotType: any;
-    Type: any;
-}> = IT["CreationType"] | IT["SnapshotType"] | IT["Type"];
-/**
- * The instance representation of a given type.
- */
-export type Instance<T> = T extends {
-    [$type]: undefined;
-    Type: any;
-} ? T["Type"] : T;
-/**
- * The input (creation) snapshot representation of a given type.
- */
-export type SnapshotIn<T> = T extends {
-    [$type]: undefined;
-    CreationType: any;
-} ? T["CreationType"] : T extends IStateTreeNode<infer IT> ? IT["CreationType"] : T;
-/**
- * The output snapshot representation of a given type.
- */
-export type SnapshotOut<T> = T extends {
-    [$type]: undefined;
-    SnapshotType: any;
-} ? T["SnapshotType"] : T extends IStateTreeNode<infer IT> ? IT["SnapshotType"] : T;
-/**
- * A type which is equivalent to the union of SnapshotIn and Instance types of a given typeof TYPE or typeof VARIABLE.
- * For primitives it defaults to the primitive itself.
- *
- * For example:
- * - `SnapshotOrInstance<typeof ModelA> = SnapshotIn<typeof ModelA> | Instance<typeof ModelA>`
- * - `SnapshotOrInstance<typeof self.a (where self.a is a ModelA)> = SnapshotIn<typeof ModelA> | Instance<typeof ModelA>`
- *
- * Usually you might want to use this when your model has a setter action that sets a property.
- *
- * Example:
- * ```ts
- * const ModelA = types.model({
- *   n: types.number
- * })
- *
- * const ModelB = types.model({
- *   innerModel: ModelA
- * }).actions(self => ({
- *   // this will accept as property both the snapshot and the instance, whichever is preferred
- *   setInnerModel(m: SnapshotOrInstance<typeof self.innerModel>) {
- *     self.innerModel = cast(m)
- *   }
- * }))
- * ```
- */
-export type SnapshotOrInstance<T> = SnapshotIn<T> | Instance<T>;
-/**
- * A base type produces a MST node (Node in the state tree)
- *
- * @internal
- * @hidden
- */
-export declare abstract class BaseType<C, S, T, N extends BaseNode<any, any, any> = BaseNode<C, S, T>> implements IType<C, S, T> {
-    [$type]: undefined;
-    readonly C: C;
-    readonly S: S;
-    readonly T: T;
-    readonly N: N;
-    readonly isType = true;
-    readonly name: string;
-    constructor(name: string);
-    create(snapshot?: C, environment?: any): any;
-    getSnapshot(_node: N, _applyPostProcess?: boolean): S;
-    abstract reconcile(current: N, newValue: C | T, parent: AnyObjectNode, subpath: string): N;
-    abstract instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: C | T): N;
-    abstract flags: TypeFlags;
-    abstract describe(): string;
-    abstract isValidSnapshot(value: C, context: IValidationContext): IValidationResult;
-    isAssignableFrom(type: IAnyType): boolean;
-    validate(value: C | T, context: IValidationContext): IValidationResult;
-    is(thing: any): thing is any;
-    get Type(): any;
-    get TypeWithoutSTN(): any;
-    get SnapshotType(): any;
-    get CreationType(): any;
-    abstract getSubTypes(): IAnyType[] | IAnyType | null | typeof cannotDetermineSubtype;
-}
-/**
- * @internal
- * @hidden
- */
-export type AnyBaseType = BaseType<any, any, any, any>;
-/**
- * @internal
- * @hidden
- */
-export type ExtractNodeType<IT extends IAnyType> = IT extends BaseType<any, any, any, infer N> ? N : never;
-/**
- * A complex type produces a MST node (Node in the state tree)
- *
- * @internal
- * @hidden
- */
-export declare abstract class ComplexType<C, S, T> extends BaseType<C, S, T, ObjectNode<C, S, T>> {
-    identifierAttribute?: string;
-    constructor(name: string);
-    create(snapshot?: C, environment?: any): any;
-    getValue(node: this["N"]): T;
-    abstract getDefaultSnapshot(): C;
-    abstract createNewInstance(childNodes: IChildNodesMap): T;
-    abstract finalizeNewInstance(node: this["N"], instance: any): void;
-    abstract applySnapshot(node: this["N"], snapshot: C): void;
-    abstract applyPatchLocally(node: this["N"], subpath: string, patch: IJsonPatch): void;
-    abstract processInitialSnapshot(childNodes: IChildNodesMap, snapshot: C): S;
-    abstract getChildren(node: this["N"]): ReadonlyArray<AnyNode>;
-    abstract getChildNode(node: this["N"], key: string): AnyNode;
-    abstract getChildType(propertyName?: string): IAnyType;
-    abstract initializeChildNodes(node: this["N"], snapshot: any): IChildNodesMap;
-    abstract removeChild(node: this["N"], subpath: string): void;
-    isMatchingSnapshotId(current: this["N"], snapshot: C): boolean;
-    private tryToReconcileNode;
-    reconcile(current: this["N"], newValue: C | T, parent: AnyObjectNode, subpath: string): this["N"];
-    getSubTypes(): null;
-}
-/**
- * @internal
- * @hidden
- */
-export declare abstract class SimpleType<C, S, T> extends BaseType<C, S, T, ScalarNode<C, S, T>> {
-    abstract instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: C): this["N"];
-    createNewInstance(snapshot: C): T;
-    getValue(node: this["N"]): T;
-    getSnapshot(node: this["N"]): S;
-    reconcile(current: this["N"], newValue: C, parent: AnyObjectNode, subpath: string): this["N"];
-    getSubTypes(): null;
-}
-/**
- * Returns if a given value represents a type.
- *
- * @param value Value to check.
- * @returns `true` if the value is a type.
- */
-export declare function isType(value: any): value is IAnyType;
-/**
- * @internal
- * @hidden
- */
-export declare function assertIsType(type: IAnyType, argNumber: number | number[]): void;
-export {};

package/esm/core/type/type.js

@@ -1,243 +0,0 @@
-import { action } from "mobx";
-import { assertArg, fail, getStateTreeNode, getStateTreeNodeSafe, getType, isMutable, isStateTreeNode, normalizeIdentifier, typeCheckFailure, typeCheckSuccess, typecheckInternal } from "../../internal.js";
-// Cache for validation results to avoid re-validating the same object against the same type
-// Uses WeakMap so cached objects can be garbage collected
-const validationCache = new WeakMap();
-/**
- * @internal
- * @hidden
- */
-export var TypeFlags;
-(function (TypeFlags) {
-    TypeFlags[TypeFlags["String"] = 1] = "String";
-    TypeFlags[TypeFlags["Number"] = 2] = "Number";
-    TypeFlags[TypeFlags["Boolean"] = 4] = "Boolean";
-    TypeFlags[TypeFlags["Date"] = 8] = "Date";
-    TypeFlags[TypeFlags["Literal"] = 16] = "Literal";
-    TypeFlags[TypeFlags["Array"] = 32] = "Array";
-    TypeFlags[TypeFlags["Map"] = 64] = "Map";
-    TypeFlags[TypeFlags["Object"] = 128] = "Object";
-    TypeFlags[TypeFlags["Frozen"] = 256] = "Frozen";
-    TypeFlags[TypeFlags["Optional"] = 512] = "Optional";
-    TypeFlags[TypeFlags["Reference"] = 1024] = "Reference";
-    TypeFlags[TypeFlags["Identifier"] = 2048] = "Identifier";
-    TypeFlags[TypeFlags["Late"] = 4096] = "Late";
-    TypeFlags[TypeFlags["Refinement"] = 8192] = "Refinement";
-    TypeFlags[TypeFlags["Union"] = 16384] = "Union";
-    TypeFlags[TypeFlags["Null"] = 32768] = "Null";
-    TypeFlags[TypeFlags["Undefined"] = 65536] = "Undefined";
-    TypeFlags[TypeFlags["Integer"] = 131072] = "Integer";
-    TypeFlags[TypeFlags["Custom"] = 262144] = "Custom";
-    TypeFlags[TypeFlags["SnapshotProcessor"] = 524288] = "SnapshotProcessor";
-    TypeFlags[TypeFlags["Lazy"] = 1048576] = "Lazy";
-    TypeFlags[TypeFlags["Finite"] = 2097152] = "Finite";
-    TypeFlags[TypeFlags["Float"] = 4194304] = "Float";
-})(TypeFlags || (TypeFlags = {}));
-/**
- * @internal
- * @hidden
- */
-export const cannotDetermineSubtype = "cannotDetermine";
-/** @hidden */
-const $type = Symbol("$type");
-/**
- * A base type produces a MST node (Node in the state tree)
- *
- * @internal
- * @hidden
- */
-export class BaseType {
-    [$type];
-    // these are just to make inner types avaialable to inherited classes
-    C;
-    S;
-    T;
-    N;
-    isType = true;
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-    create(snapshot, environment) {
-        typecheckInternal(this, snapshot);
-        return this.instantiate(null, "", environment, snapshot).value;
-    }
-    getSnapshot(_node, _applyPostProcess) {
-        // istanbul ignore next
-        throw fail("unimplemented method");
-    }
-    isAssignableFrom(type) {
-        return type === this;
-    }
-    validate(value, context) {
-        const node = getStateTreeNodeSafe(value);
-        if (node) {
-            const valueType = getType(value);
-            return this.isAssignableFrom(valueType)
-                ? typeCheckSuccess()
-                : typeCheckFailure(context, value);
-            // it is tempting to compare snapshots, but in that case we should always clone on assignments...
-        }
-        // check cache for object values (only at root level to avoid context mismatches)
-        if (typeof value === "object" && value !== null && context.length === 1) {
-            const typeCache = validationCache.get(value);
-            if (typeCache) {
-                const cached = typeCache.get(this);
-                if (cached !== undefined) {
-                    return cached;
-                }
-            }
-        }
-        const result = this.isValidSnapshot(value, context);
-        // cache result for object values (only at root level)
-        if (typeof value === "object" && value !== null && context.length === 1) {
-            let typeCache = validationCache.get(value);
-            if (!typeCache) {
-                typeCache = new WeakMap();
-                validationCache.set(value, typeCache);
-            }
-            typeCache.set(this, result);
-        }
-        return result;
-    }
-    is(thing) {
-        return this.validate(thing, [{ path: "", type: this }]).length === 0;
-    }
-    get Type() {
-        // istanbul ignore next
-        throw fail("Factory.Type should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.Type`");
-    }
-    get TypeWithoutSTN() {
-        // istanbul ignore next
-        throw fail("Factory.TypeWithoutSTN should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.TypeWithoutSTN`");
-    }
-    get SnapshotType() {
-        // istanbul ignore next
-        throw fail("Factory.SnapshotType should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.SnapshotType`");
-    }
-    get CreationType() {
-        // istanbul ignore next
-        throw fail("Factory.CreationType should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.CreationType`");
-    }
-}
-BaseType.prototype.create = action(BaseType.prototype.create);
-/**
- * A complex type produces a MST node (Node in the state tree)
- *
- * @internal
- * @hidden
- */
-export class ComplexType extends BaseType {
-    identifierAttribute;
-    constructor(name) {
-        super(name);
-    }
-    create(snapshot = this.getDefaultSnapshot(), environment) {
-        return super.create(snapshot, environment);
-    }
-    getValue(node) {
-        node.createObservableInstanceIfNeeded();
-        return node.storedValue;
-    }
-    isMatchingSnapshotId(current, snapshot) {
-        return (!current.identifierAttribute ||
-            current.identifier ===
-                normalizeIdentifier(snapshot[current.identifierAttribute]));
-    }
-    tryToReconcileNode(current, newValue) {
-        if (current.isDetaching) {
-            return false;
-        }
-        if (current.snapshot === newValue) {
-            // newValue is the current snapshot of the node, noop
-            return true;
-        }
-        if (isStateTreeNode(newValue) && getStateTreeNode(newValue) === current) {
-            // the current node is the same as the new one
-            return true;
-        }
-        if (current.type === this &&
-            isMutable(newValue) &&
-            !isStateTreeNode(newValue) &&
-            this.isMatchingSnapshotId(current, newValue)) {
-            // the newValue has no node, so can be treated like a snapshot
-            // we can reconcile
-            current.applySnapshot(newValue);
-            return true;
-        }
-        return false;
-    }
-    reconcile(current, newValue, parent, subpath) {
-        const nodeReconciled = this.tryToReconcileNode(current, newValue);
-        if (nodeReconciled) {
-            current.setParent(parent, subpath);
-            return current;
-        }
-        // current node cannot be recycled in any way
-        current.die(); // noop if detaching
-        // attempt to reuse the new one
-        if (isStateTreeNode(newValue) && this.isAssignableFrom(getType(newValue))) {
-            // newValue is a Node as well, move it here..
-            const newNode = getStateTreeNode(newValue);
-            newNode.setParent(parent, subpath);
-            return newNode;
-        }
-        // nothing to do, we have to create a new node
-        return this.instantiate(parent, subpath, undefined, newValue);
-    }
-    getSubTypes() {
-        return null;
-    }
-}
-ComplexType.prototype.create = action(ComplexType.prototype.create);
-/**
- * @internal
- * @hidden
- */
-export class SimpleType extends BaseType {
-    createNewInstance(snapshot) {
-        return snapshot;
-    }
-    getValue(node) {
-        // if we ever find a case where scalar nodes can be accessed without iterating through its parent
-        // uncomment this to make sure the parent chain is created when this is accessed
-        // if (node.parent) {
-        //     node.parent.createObservableInstanceIfNeeded()
-        // }
-        return node.storedValue;
-    }
-    getSnapshot(node) {
-        return node.storedValue;
-    }
-    reconcile(current, newValue, parent, subpath) {
-        // reconcile only if type and value are still the same, and only if the node is not detaching
-        if (!current.isDetaching &&
-            current.type === this &&
-            current.storedValue === newValue) {
-            return current;
-        }
-        const res = this.instantiate(parent, subpath, undefined, newValue);
-        current.die(); // noop if detaching
-        return res;
-    }
-    getSubTypes() {
-        return null;
-    }
-}
-/**
- * Returns if a given value represents a type.
- *
- * @param value Value to check.
- * @returns `true` if the value is a type.
- */
-export function isType(value) {
-    return typeof value === "object" && value && value.isType === true;
-}
-/**
- * @internal
- * @hidden
- */
-export function assertIsType(type, argNumber) {
-    assertArg(type, isType, "mobx-state-tree type", argNumber);
-}
-//# sourceMappingURL=type.js.map

package/esm/core/type/type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"type.js","sourceRoot":"","sources":["../../../src/core/type/type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE7B,OAAO,EAEL,SAAS,EACT,IAAI,EACJ,gBAAgB,EAChB,oBAAoB,EACpB,OAAO,EACP,SAAS,EACT,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,mBAAmB,CAAA;AAE1B,4FAA4F;AAC5F,0DAA0D;AAC1D,MAAM,eAAe,GAAG,IAAI,OAAO,EAGhC,CAAA;AAeH;;;GAGG;AACH,MAAM,CAAN,IAAY,SAwBX;AAxBD,WAAY,SAAS;IACnB,6CAAU,CAAA;IACV,6CAAe,CAAA;IACf,+CAAgB,CAAA;IAChB,yCAAa,CAAA;IACb,gDAAgB,CAAA;IAChB,4CAAc,CAAA;IACd,wCAAY,CAAA;IACZ,+CAAe,CAAA;IACf,+CAAe,CAAA;IACf,mDAAiB,CAAA;IACjB,sDAAmB,CAAA;IACnB,wDAAoB,CAAA;IACpB,4CAAc,CAAA;IACd,wDAAoB,CAAA;IACpB,+CAAe,CAAA;IACf,6CAAc,CAAA;IACd,uDAAmB,CAAA;IACnB,oDAAiB,CAAA;IACjB,kDAAgB,CAAA;IAChB,wEAA2B,CAAA;IAC3B,+CAAc,CAAA;IACd,mDAAgB,CAAA;IAChB,iDAAe,CAAA;AACjB,CAAC,EAxBW,SAAS,KAAT,SAAS,QAwBpB;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,iBAAiB,CAAA;AAUvD,cAAc;AACd,MAAM,KAAK,GAAkB,MAAM,CAAC,OAAO,CAAC,CAAA;AA2N5C;;;;;GAKG;AACH,MAAM,OAAgB,QAAQ;IAM5B,CAAC,KAAK,CAAC,CAAY;IAEnB,qEAAqE;IAC5D,CAAC,CAAI;IACL,CAAC,CAAI;IACL,CAAC,CAAI;IACL,CAAC,CAAI;IAEL,MAAM,GAAG,IAAI,CAAA;IACb,IAAI,CAAQ;IAErB,YAAY,IAAY;QACtB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IAED,MAAM,CAAC,QAAY,EAAE,WAAiB;QACpC,iBAAiB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;QACjC,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,EAAE,WAAW,EAAE,QAAS,CAAC,CAAC,KAAK,CAAA;IACjE,CAAC;IAED,WAAW,CAAC,KAAQ,EAAE,iBAA2B;QAC/C,uBAAuB;QACvB,MAAM,IAAI,CAAC,sBAAsB,CAAC,CAAA;IACpC,CAAC;IAwBD,gBAAgB,CAAC,IAAc;QAC7B,OAAO,IAAI,KAAK,IAAI,CAAA;IACtB,CAAC;IAED,QAAQ,CAAC,KAAY,EAAE,OAA2B;QAChD,MAAM,IAAI,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAA;QACxC,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;YAChC,OAAO,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC;gBACrC,CAAC,CAAC,gBAAgB,EAAE;gBACpB,CAAC,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;YACpC,iGAAiG;QACnG,CAAC;QAED,iFAAiF;QACjF,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxE,MAAM,SAAS,GAAG,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;YAC5C,IAAI,SAAS,EAAE,CAAC;gBACd,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;gBAClC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;oBACzB,OAAO,MAAM,CAAA;gBACf,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,KAAU,EAAE,OAAO,CAAC,CAAA;QAExD,sDAAsD;QACtD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxE,IAAI,SAAS,GAAG,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;YAC1C,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,SAAS,GAAG,IAAI,OAAO,EAAE,CAAA;gBACzB,eAAe,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;YACvC,CAAC;YACD,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAC7B,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;IAED,EAAE,CAAC,KAAU;QACX,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAA;IACtE,CAAC;IAED,IAAI,IAAI;QACN,uBAAuB;QACvB,MAAM,IAAI,CACR,uJAAuJ,CACxJ,CAAA;IACH,CAAC;IACD,IAAI,cAAc;QAChB,uBAAuB;QACvB,MAAM,IAAI,CACR,2KAA2K,CAC5K,CAAA;IACH,CAAC;IACD,IAAI,YAAY;QACd,uBAAuB;QACvB,MAAM,IAAI,CACR,uKAAuK,CACxK,CAAA;IACH,CAAC;IACD,IAAI,YAAY;QACd,uBAAuB;QACvB,MAAM,IAAI,CACR,uKAAuK,CACxK,CAAA;IACH,CAAC;CAOF;AACD,QAAQ,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;AAe7D;;;;;GAKG;AACH,MAAM,OAAgB,WAAqB,SAAQ,QAKlD;IACC,mBAAmB,CAAS;IAE5B,YAAY,IAAY;QACtB,KAAK,CAAC,IAAI,CAAC,CAAA;IACb,CAAC;IAED,MAAM,CAAC,WAAc,IAAI,CAAC,kBAAkB,EAAE,EAAE,WAAiB;QAC/D,OAAO,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAA;IAC5C,CAAC;IAED,QAAQ,CAAC,IAAe;QACtB,IAAI,CAAC,gCAAgC,EAAE,CAAA;QACvC,OAAO,IAAI,CAAC,WAAW,CAAA;IACzB,CAAC;IAqBD,oBAAoB,CAAC,OAAkB,EAAE,QAAW;QAClD,OAAO,CACL,CAAC,OAAO,CAAC,mBAAmB;YAC5B,OAAO,CAAC,UAAU;gBAChB,mBAAmB,CAAE,QAAgB,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CACtE,CAAA;IACH,CAAC;IAEO,kBAAkB,CAAC,OAAkB,EAAE,QAAe;QAC5D,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YACxB,OAAO,KAAK,CAAA;QACd,CAAC;QACD,IAAK,OAAO,CAAC,QAAgB,KAAK,QAAQ,EAAE,CAAC;YAC3C,qDAAqD;YACrD,OAAO,IAAI,CAAA;QACb,CAAC;QACD,IAAI,eAAe,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,QAAQ,CAAC,KAAK,OAAO,EAAE,CAAC;YACxE,8CAA8C;YAC9C,OAAO,IAAI,CAAA;QACb,CAAC;QACD,IACE,OAAO,CAAC,IAAI,KAAK,IAAI;YACrB,SAAS,CAAC,QAAQ,CAAC;YACnB,CAAC,eAAe,CAAC,QAAQ,CAAC;YAC1B,IAAI,CAAC,oBAAoB,CAAC,OAAO,EAAE,QAAe,CAAC,EACnD,CAAC;YACD,8DAA8D;YAC9D,mBAAmB;YACnB,OAAO,CAAC,aAAa,CAAC,QAAa,CAAC,CAAA;YACpC,OAAO,IAAI,CAAA;QACb,CAAC;QACD,OAAO,KAAK,CAAA;IACd,CAAC;IAED,SAAS,CACP,OAAkB,EAClB,QAAe,EACf,MAAqB,EACrB,OAAe;QAEf,MAAM,cAAc,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;QACjE,IAAI,cAAc,EAAE,CAAC;YACnB,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;YAClC,OAAO,OAAO,CAAA;QAChB,CAAC;QAED,6CAA6C;QAC7C,OAAO,CAAC,GAAG,EAAE,CAAA,CAAC,oBAAoB;QAClC,+BAA+B;QAC/B,IAAI,eAAe,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;YAC1E,6CAA6C;YAC7C,MAAM,OAAO,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAA;YAC1C,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;YAClC,OAAO,OAAO,CAAA;QAChB,CAAC;QACD,8CAA8C;QAC9C,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAA;IAC/D,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAA;IACb,CAAC;CACF;AACD,WAAW,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;AAEnE;;;GAGG;AACH,MAAM,OAAgB,UAAoB,SAAQ,QAKjD;IAQC,iBAAiB,CAAC,QAAW;QAC3B,OAAO,QAAe,CAAA;IACxB,CAAC;IAED,QAAQ,CAAC,IAAe;QACtB,iGAAiG;QACjG,gFAAgF;QAChF,qBAAqB;QACrB,qDAAqD;QACrD,IAAI;QACJ,OAAO,IAAI,CAAC,WAAW,CAAA;IACzB,CAAC;IAED,WAAW,CAAC,IAAe;QACzB,OAAO,IAAI,CAAC,WAAW,CAAA;IACzB,CAAC;IAED,SAAS,CACP,OAAkB,EAClB,QAAW,EACX,MAAqB,EACrB,OAAe;QAEf,6FAA6F;QAC7F,IACE,CAAC,OAAO,CAAC,WAAW;YACpB,OAAO,CAAC,IAAI,KAAK,IAAI;YACrB,OAAO,CAAC,WAAW,KAAK,QAAQ,EAChC,CAAC;YACD,OAAO,OAAO,CAAA;QAChB,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAA;QAClE,OAAO,CAAC,GAAG,EAAE,CAAA,CAAC,oBAAoB;QAClC,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAA;IACb,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAC,KAAU;IAC/B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAA;AACpE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,IAAc,EAAE,SAA4B;IACvE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,sBAAsB,EAAE,SAAS,CAAC,CAAA;AAC5D,CAAC","sourcesContent":["import { action } from \"mobx\"\n\nimport {\n  BaseNode,\n  assertArg,\n  fail,\n  getStateTreeNode,\n  getStateTreeNodeSafe,\n  getType,\n  isMutable,\n  isStateTreeNode,\n  normalizeIdentifier,\n  typeCheckFailure,\n  typeCheckSuccess,\n  typecheckInternal\n} from \"../../internal.ts\"\n\n// Cache for validation results to avoid re-validating the same object against the same type\n// Uses WeakMap so cached objects can be garbage collected\nconst validationCache = new WeakMap<\n  object,\n  WeakMap<BaseType<any, any, any, any>, IValidationResult>\n>()\n\nimport type {\n  AnyNode,\n  AnyObjectNode,\n  IChildNodesMap,\n  IJsonPatch,\n  IStateTreeNode,\n  IValidationContext,\n  IValidationResult,\n  ModelPrimitive,\n  ObjectNode,\n  ScalarNode\n} from \"../../internal.ts\"\n\n/**\n * @internal\n * @hidden\n */\nexport enum TypeFlags {\n  String = 1,\n  Number = 1 << 1,\n  Boolean = 1 << 2,\n  Date = 1 << 3,\n  Literal = 1 << 4,\n  Array = 1 << 5,\n  Map = 1 << 6,\n  Object = 1 << 7,\n  Frozen = 1 << 8,\n  Optional = 1 << 9,\n  Reference = 1 << 10,\n  Identifier = 1 << 11,\n  Late = 1 << 12,\n  Refinement = 1 << 13,\n  Union = 1 << 14,\n  Null = 1 << 15,\n  Undefined = 1 << 16,\n  Integer = 1 << 17,\n  Custom = 1 << 18,\n  SnapshotProcessor = 1 << 19,\n  Lazy = 1 << 20,\n  Finite = 1 << 21,\n  Float = 1 << 22\n}\n\n/**\n * @internal\n * @hidden\n */\nexport const cannotDetermineSubtype = \"cannotDetermine\"\n\n/**\n * A state tree node value.\n * @hidden\n */\nexport type STNValue<T, IT extends IAnyType> = T extends object\n  ? T & IStateTreeNode<IT>\n  : T\n\n/** @hidden */\nconst $type: unique symbol = Symbol(\"$type\")\n\n/**\n * A type, either complex or simple.\n */\nexport interface IType<C, S, T> {\n  // fake, will never be present, just for typing\n  /** @hidden */\n  readonly [$type]: undefined\n\n  /**\n   * Friendly type name.\n   */\n  name: string\n\n  /**\n   * Name of the identifier attribute or null if none.\n   */\n  readonly identifierAttribute?: string\n\n  /**\n   * Creates an instance for the type given an snapshot input.\n   *\n   * @returns An instance of that type.\n   */\n  create(snapshot?: C, env?: any): this[\"Type\"]\n\n  /**\n   * Checks if a given snapshot / instance is of the given type.\n   *\n   * @param thing Snapshot or instance to be checked.\n   * @returns true if the value is of the current type, false otherwise.\n   */\n  is(thing: any): thing is C | this[\"Type\"]\n\n  /**\n   * Run's the type's typechecker on the given value with the given validation context.\n   *\n   * @param thing Value to be checked, either a snapshot or an instance.\n   * @param context Validation context, an array of { subpaths, subtypes } that should be validated\n   * @returns The validation result, an array with the list of validation errors.\n   */\n  validate(thing: C, context: IValidationContext): IValidationResult\n\n  /**\n   * Gets the textual representation of the type as a string.\n   */\n  describe(): string\n\n  /**\n   * @deprecated use `Instance<typeof MyType>` instead.\n   * @hidden\n   */\n  readonly Type: STNValue<T, this>\n\n  /**\n   * @deprecated do not use.\n   * @hidden\n   */\n  readonly TypeWithoutSTN: T\n\n  /**\n   * @deprecated use `SnapshotOut<typeof MyType>` instead.\n   * @hidden\n   */\n  readonly SnapshotType: S\n\n  /**\n   * @deprecated use `SnapshotIn<typeof MyType>` instead.\n   * @hidden\n   */\n  readonly CreationType: C\n\n  // Internal api's\n\n  /**\n   * @internal\n   * @hidden\n   */\n  flags: TypeFlags\n  /**\n   * @internal\n   * @hidden\n   */\n  isType: true\n  /**\n   * @internal\n   * @hidden\n   */\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: C | T\n  ): BaseNode<C, S, T>\n  /**\n   * @internal\n   * @hidden\n   */\n  reconcile(\n    current: BaseNode<C, S, T>,\n    newValue: C | T,\n    parent: AnyObjectNode,\n    subpath: string\n  ): BaseNode<C, S, T>\n  /**\n   * @internal\n   * @hidden\n   */\n  getSnapshot(node: BaseNode<C, S, T>, applyPostProcess?: boolean): S\n  /**\n   * @internal\n   * @hidden\n   */\n  isAssignableFrom(type: IAnyType): boolean\n  /**\n   * @internal\n   * @hidden\n   */\n  getSubTypes(): IAnyType[] | IAnyType | null | typeof cannotDetermineSubtype\n}\n\n/**\n * Any kind of type.\n */\nexport interface IAnyType extends IType<any, any, any> {}\n\n/**\n * A simple type, this is, a type where the instance and the snapshot representation are the same.\n */\nexport interface ISimpleType<T> extends IType<T, T, T> {}\n\n/** @hidden */\nexport type Primitives = ModelPrimitive | null | undefined\n\n/**\n * A complex type.\n * @deprecated just for compatibility with old versions, could be deprecated on the next major version\n * @hidden\n */\nexport interface IComplexType<C, S, T> extends IType<C, S, T & object> {}\n\n/**\n * Any kind of complex type.\n */\nexport interface IAnyComplexType extends IType<any, any, object> {}\n\n/** @hidden */\nexport type ExtractCSTWithoutSTN<\n  IT extends {\n    [$type]: undefined\n    CreationType: any\n    SnapshotType: any\n    TypeWithoutSTN: any\n  }\n> = IT[\"CreationType\"] | IT[\"SnapshotType\"] | IT[\"TypeWithoutSTN\"]\n/** @hidden */\nexport type ExtractCSTWithSTN<\n  IT extends {\n    [$type]: undefined\n    CreationType: any\n    SnapshotType: any\n    Type: any\n  }\n> = IT[\"CreationType\"] | IT[\"SnapshotType\"] | IT[\"Type\"]\n\n/**\n * The instance representation of a given type.\n */\nexport type Instance<T> = T extends { [$type]: undefined; Type: any }\n  ? T[\"Type\"]\n  : T\n\n/**\n * The input (creation) snapshot representation of a given type.\n */\nexport type SnapshotIn<T> = T extends { [$type]: undefined; CreationType: any }\n  ? T[\"CreationType\"]\n  : T extends IStateTreeNode<infer IT>\n    ? IT[\"CreationType\"]\n    : T\n\n/**\n * The output snapshot representation of a given type.\n */\nexport type SnapshotOut<T> = T extends { [$type]: undefined; SnapshotType: any }\n  ? T[\"SnapshotType\"]\n  : T extends IStateTreeNode<infer IT>\n    ? IT[\"SnapshotType\"]\n    : T\n\n/**\n * A type which is equivalent to the union of SnapshotIn and Instance types of a given typeof TYPE or typeof VARIABLE.\n * For primitives it defaults to the primitive itself.\n *\n * For example:\n * - `SnapshotOrInstance<typeof ModelA> = SnapshotIn<typeof ModelA> | Instance<typeof ModelA>`\n * - `SnapshotOrInstance<typeof self.a (where self.a is a ModelA)> = SnapshotIn<typeof ModelA> | Instance<typeof ModelA>`\n *\n * Usually you might want to use this when your model has a setter action that sets a property.\n *\n * Example:\n * ```ts\n * const ModelA = types.model({\n *   n: types.number\n * })\n *\n * const ModelB = types.model({\n *   innerModel: ModelA\n * }).actions(self => ({\n *   // this will accept as property both the snapshot and the instance, whichever is preferred\n *   setInnerModel(m: SnapshotOrInstance<typeof self.innerModel>) {\n *     self.innerModel = cast(m)\n *   }\n * }))\n * ```\n */\nexport type SnapshotOrInstance<T> = SnapshotIn<T> | Instance<T>\n\n/**\n * A base type produces a MST node (Node in the state tree)\n *\n * @internal\n * @hidden\n */\nexport abstract class BaseType<\n  C,\n  S,\n  T,\n  N extends BaseNode<any, any, any> = BaseNode<C, S, T>\n> implements IType<C, S, T> {\n  [$type]!: undefined\n\n  // these are just to make inner types avaialable to inherited classes\n  readonly C!: C\n  readonly S!: S\n  readonly T!: T\n  readonly N!: N\n\n  readonly isType = true\n  readonly name: string\n\n  constructor(name: string) {\n    this.name = name\n  }\n\n  create(snapshot?: C, environment?: any) {\n    typecheckInternal(this, snapshot)\n    return this.instantiate(null, \"\", environment, snapshot!).value\n  }\n\n  getSnapshot(_node: N, _applyPostProcess?: boolean): S {\n    // istanbul ignore next\n    throw fail(\"unimplemented method\")\n  }\n\n  abstract reconcile(\n    current: N,\n    newValue: C | T,\n    parent: AnyObjectNode,\n    subpath: string\n  ): N\n\n  abstract instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: C | T\n  ): N\n\n  declare abstract flags: TypeFlags\n  abstract describe(): string\n\n  abstract isValidSnapshot(\n    value: C,\n    context: IValidationContext\n  ): IValidationResult\n\n  isAssignableFrom(type: IAnyType): boolean {\n    return type === this\n  }\n\n  validate(value: C | T, context: IValidationContext): IValidationResult {\n    const node = getStateTreeNodeSafe(value)\n    if (node) {\n      const valueType = getType(value)\n      return this.isAssignableFrom(valueType)\n        ? typeCheckSuccess()\n        : typeCheckFailure(context, value)\n      // it is tempting to compare snapshots, but in that case we should always clone on assignments...\n    }\n\n    // check cache for object values (only at root level to avoid context mismatches)\n    if (typeof value === \"object\" && value !== null && context.length === 1) {\n      const typeCache = validationCache.get(value)\n      if (typeCache) {\n        const cached = typeCache.get(this)\n        if (cached !== undefined) {\n          return cached\n        }\n      }\n    }\n\n    const result = this.isValidSnapshot(value as C, context)\n\n    // cache result for object values (only at root level)\n    if (typeof value === \"object\" && value !== null && context.length === 1) {\n      let typeCache = validationCache.get(value)\n      if (!typeCache) {\n        typeCache = new WeakMap()\n        validationCache.set(value, typeCache)\n      }\n      typeCache.set(this, result)\n    }\n\n    return result\n  }\n\n  is(thing: any): thing is any {\n    return this.validate(thing, [{ path: \"\", type: this }]).length === 0\n  }\n\n  get Type(): any {\n    // istanbul ignore next\n    throw fail(\n      \"Factory.Type should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.Type`\"\n    )\n  }\n  get TypeWithoutSTN(): any {\n    // istanbul ignore next\n    throw fail(\n      \"Factory.TypeWithoutSTN should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.TypeWithoutSTN`\"\n    )\n  }\n  get SnapshotType(): any {\n    // istanbul ignore next\n    throw fail(\n      \"Factory.SnapshotType should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.SnapshotType`\"\n    )\n  }\n  get CreationType(): any {\n    // istanbul ignore next\n    throw fail(\n      \"Factory.CreationType should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.CreationType`\"\n    )\n  }\n\n  abstract getSubTypes():\n    | IAnyType[]\n    | IAnyType\n    | null\n    | typeof cannotDetermineSubtype\n}\nBaseType.prototype.create = action(BaseType.prototype.create)\n\n/**\n * @internal\n * @hidden\n */\nexport type AnyBaseType = BaseType<any, any, any, any>\n\n/**\n * @internal\n * @hidden\n */\nexport type ExtractNodeType<IT extends IAnyType> =\n  IT extends BaseType<any, any, any, infer N> ? N : never\n\n/**\n * A complex type produces a MST node (Node in the state tree)\n *\n * @internal\n * @hidden\n */\nexport abstract class ComplexType<C, S, T> extends BaseType<\n  C,\n  S,\n  T,\n  ObjectNode<C, S, T>\n> {\n  identifierAttribute?: string\n\n  constructor(name: string) {\n    super(name)\n  }\n\n  create(snapshot: C = this.getDefaultSnapshot(), environment?: any) {\n    return super.create(snapshot, environment)\n  }\n\n  getValue(node: this[\"N\"]): T {\n    node.createObservableInstanceIfNeeded()\n    return node.storedValue\n  }\n\n  abstract getDefaultSnapshot(): C\n\n  abstract createNewInstance(childNodes: IChildNodesMap): T\n  abstract finalizeNewInstance(node: this[\"N\"], instance: any): void\n\n  abstract applySnapshot(node: this[\"N\"], snapshot: C): void\n  abstract applyPatchLocally(\n    node: this[\"N\"],\n    subpath: string,\n    patch: IJsonPatch\n  ): void\n  abstract processInitialSnapshot(childNodes: IChildNodesMap, snapshot: C): S\n\n  abstract getChildren(node: this[\"N\"]): ReadonlyArray<AnyNode>\n  abstract getChildNode(node: this[\"N\"], key: string): AnyNode\n  abstract getChildType(propertyName?: string): IAnyType\n  abstract initializeChildNodes(node: this[\"N\"], snapshot: any): IChildNodesMap\n  abstract removeChild(node: this[\"N\"], subpath: string): void\n\n  isMatchingSnapshotId(current: this[\"N\"], snapshot: C): boolean {\n    return (\n      !current.identifierAttribute ||\n      current.identifier ===\n        normalizeIdentifier((snapshot as any)[current.identifierAttribute])\n    )\n  }\n\n  private tryToReconcileNode(current: this[\"N\"], newValue: C | T) {\n    if (current.isDetaching) {\n      return false\n    }\n    if ((current.snapshot as any) === newValue) {\n      // newValue is the current snapshot of the node, noop\n      return true\n    }\n    if (isStateTreeNode(newValue) && getStateTreeNode(newValue) === current) {\n      // the current node is the same as the new one\n      return true\n    }\n    if (\n      current.type === this &&\n      isMutable(newValue) &&\n      !isStateTreeNode(newValue) &&\n      this.isMatchingSnapshotId(current, newValue as any)\n    ) {\n      // the newValue has no node, so can be treated like a snapshot\n      // we can reconcile\n      current.applySnapshot(newValue as C)\n      return true\n    }\n    return false\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    newValue: C | T,\n    parent: AnyObjectNode,\n    subpath: string\n  ): this[\"N\"] {\n    const nodeReconciled = this.tryToReconcileNode(current, newValue)\n    if (nodeReconciled) {\n      current.setParent(parent, subpath)\n      return current\n    }\n\n    // current node cannot be recycled in any way\n    current.die() // noop if detaching\n    // attempt to reuse the new one\n    if (isStateTreeNode(newValue) && this.isAssignableFrom(getType(newValue))) {\n      // newValue is a Node as well, move it here..\n      const newNode = getStateTreeNode(newValue)\n      newNode.setParent(parent, subpath)\n      return newNode\n    }\n    // nothing to do, we have to create a new node\n    return this.instantiate(parent, subpath, undefined, newValue)\n  }\n\n  getSubTypes() {\n    return null\n  }\n}\nComplexType.prototype.create = action(ComplexType.prototype.create)\n\n/**\n * @internal\n * @hidden\n */\nexport abstract class SimpleType<C, S, T> extends BaseType<\n  C,\n  S,\n  T,\n  ScalarNode<C, S, T>\n> {\n  abstract instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: C\n  ): this[\"N\"]\n\n  createNewInstance(snapshot: C): T {\n    return snapshot as any\n  }\n\n  getValue(node: this[\"N\"]): T {\n    // if we ever find a case where scalar nodes can be accessed without iterating through its parent\n    // uncomment this to make sure the parent chain is created when this is accessed\n    // if (node.parent) {\n    //     node.parent.createObservableInstanceIfNeeded()\n    // }\n    return node.storedValue\n  }\n\n  getSnapshot(node: this[\"N\"]): S {\n    return node.storedValue\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    newValue: C,\n    parent: AnyObjectNode,\n    subpath: string\n  ): this[\"N\"] {\n    // reconcile only if type and value are still the same, and only if the node is not detaching\n    if (\n      !current.isDetaching &&\n      current.type === this &&\n      current.storedValue === newValue\n    ) {\n      return current\n    }\n    const res = this.instantiate(parent, subpath, undefined, newValue)\n    current.die() // noop if detaching\n    return res\n  }\n\n  getSubTypes() {\n    return null\n  }\n}\n\n/**\n * Returns if a given value represents a type.\n *\n * @param value Value to check.\n * @returns `true` if the value is a type.\n */\nexport function isType(value: any): value is IAnyType {\n  return typeof value === \"object\" && value && value.isType === true\n}\n\n/**\n * @internal\n * @hidden\n */\nexport function assertIsType(type: IAnyType, argNumber: number | number[]) {\n  assertArg(type, isType, \"mobx-state-tree type\", argNumber)\n}\n"]}

package/esm/index.d.ts

@@ -1,2 +0,0 @@
-export type { CustomTypeOptions, IActionContext, IActionRecorder, IActionTrackingMiddleware2Call, IActionTrackingMiddleware2Hooks, IActionTrackingMiddlewareHooks, IAnyComplexType, IAnyModelType, IAnyStateTreeNode, IAnyType, IArrayType, IComplexType, IDisposer, IJsonPatch, IMSTArray, IMSTMap, IMapType, IMaybe, IMaybeIType, IMaybeNull, IMiddlewareEvent, IMiddlewareEventType, IMiddlewareHandler, IModelReflectionData, IModelReflectionPropertiesData, IModelType, IOptionalIType, IPatchRecorder, IReferenceType, IReversibleJsonPatch, ISerializedActionCall, ISimpleType, ISnapshotProcessor, ISnapshotProcessors, IStateTreeNode, IType, ITypeUnion, Instance, LivelinessMode, LivelynessMode, ModelActions, ModelCreationType2, ModelCreationType, ModelInstanceType, ModelInstanceTypeProps, ModelPrimitive, ModelProperties, ModelPropertiesDeclaration, ModelPropertiesDeclarationToProperties, ModelSnapshotType2, ModelSnapshotType, OnReferenceInvalidated, OnReferenceInvalidatedEvent, OptionalDefaultValueOrFunction, ReferenceIdentifier, ReferenceOptions, ReferenceOptionsGetSet, ReferenceOptionsOnInvalidated, SnapshotIn, SnapshotOrInstance, SnapshotOut, TypeOfValue, TypeOrStateTreeNodeToStateTreeNode, UnionOptions, UnionStringArray, ValidOptionalValue, ValidOptionalValues, _CustomCSProcessor, _CustomJoin, _CustomOrOther, _NotCustomized, NonEmptyObject, ExtractCFromProps } from "./internal.ts";
-export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware2, createActionTrackingMiddleware, decorate, destroy, detach, escapeJsonPath, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, process, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setLivelinessChecking, setLivelynessChecking, splitJsonPath, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, types as t, unescapeJsonPath, unprotect, walk, setDevMode } from "./internal.ts";

package/esm/index.js

@@ -1,2 +0,0 @@
-export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware2, createActionTrackingMiddleware, decorate, destroy, detach, escapeJsonPath, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, process, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setLivelinessChecking, setLivelynessChecking, splitJsonPath, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, types as t, unescapeJsonPath, unprotect, walk, setDevMode } from "./internal.js";
-//# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA6EA,OAAO,EACL,WAAW,EACX,aAAa,EACb,WAAW,EACX,UAAU,EACV,aAAa,EACb,IAAI,EACJ,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,KAAK,EACL,+BAA+B,EAC/B,8BAA8B,EAC9B,QAAQ,EACR,OAAO,EACP,MAAM,EACN,cAAc,EACd,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,aAAa,EACb,qBAAqB,EACrB,UAAU,EACV,SAAS,EACT,SAAS,EACT,eAAe,EACf,OAAO,EACP,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,OAAO,EACP,uBAAuB,EACvB,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,sBAAsB,EACtB,4BAA4B,EAC5B,OAAO,EACP,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,aAAa,EACb,SAAS,EACT,WAAW,EACX,cAAc,EACd,eAAe,EACf,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,MAAM,EACN,eAAe,EACf,MAAM,EACN,WAAW,EACX,gBAAgB,EAChB,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,UAAU,EACV,OAAO,EACP,OAAO,EACP,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,aAAa,EACb,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,UAAU,EACV,SAAS,EACT,KAAK,EACL,KAAK,IAAI,CAAC,EACV,gBAAgB,EAChB,SAAS,EACT,IAAI,EACJ,UAAU,EACX,MAAM,eAAe,CAAA","sourcesContent":["/* all code is initially loaded through internal, to avoid circular dep issues */\nexport type {\n  CustomTypeOptions,\n  IActionContext,\n  IActionRecorder,\n  IActionTrackingMiddleware2Call,\n  IActionTrackingMiddleware2Hooks,\n  IActionTrackingMiddlewareHooks,\n  IAnyComplexType,\n  IAnyModelType,\n  IAnyStateTreeNode,\n  IAnyType,\n  IArrayType,\n  IComplexType,\n  IDisposer,\n  IJsonPatch,\n  IMSTArray,\n  IMSTMap,\n  IMapType,\n  IMaybe,\n  IMaybeIType,\n  IMaybeNull,\n  IMiddlewareEvent,\n  IMiddlewareEventType,\n  IMiddlewareHandler,\n  IModelReflectionData,\n  IModelReflectionPropertiesData,\n  IModelType,\n  IOptionalIType,\n  IPatchRecorder,\n  IReferenceType,\n  IReversibleJsonPatch,\n  ISerializedActionCall,\n  ISimpleType,\n  ISnapshotProcessor,\n  ISnapshotProcessors,\n  IStateTreeNode,\n  IType,\n  ITypeUnion,\n  Instance,\n  LivelinessMode,\n  LivelynessMode,\n  ModelActions,\n  ModelCreationType2,\n  ModelCreationType,\n  ModelInstanceType,\n  ModelInstanceTypeProps,\n  ModelPrimitive,\n  ModelProperties,\n  ModelPropertiesDeclaration,\n  ModelPropertiesDeclarationToProperties,\n  ModelSnapshotType2,\n  ModelSnapshotType,\n  OnReferenceInvalidated,\n  OnReferenceInvalidatedEvent,\n  OptionalDefaultValueOrFunction,\n  ReferenceIdentifier,\n  ReferenceOptions,\n  ReferenceOptionsGetSet,\n  ReferenceOptionsOnInvalidated,\n  SnapshotIn,\n  SnapshotOrInstance,\n  SnapshotOut,\n  TypeOfValue,\n  TypeOrStateTreeNodeToStateTreeNode,\n  UnionOptions,\n  UnionStringArray,\n  ValidOptionalValue,\n  ValidOptionalValues,\n  _CustomCSProcessor,\n  _CustomJoin,\n  _CustomOrOther,\n  _NotCustomized,\n  NonEmptyObject,\n  ExtractCFromProps\n} from \"./internal.ts\"\n\nexport {\n  addDisposer,\n  addMiddleware,\n  applyAction,\n  applyPatch,\n  applySnapshot,\n  cast,\n  castFlowReturn,\n  castToReferenceSnapshot,\n  castToSnapshot,\n  clone,\n  createActionTrackingMiddleware2,\n  createActionTrackingMiddleware,\n  decorate,\n  destroy,\n  detach,\n  escapeJsonPath,\n  flow,\n  getChildType,\n  getEnv,\n  getIdentifier,\n  getLivelinessChecking,\n  getMembers,\n  getNodeId,\n  getParent,\n  getParentOfType,\n  getPath,\n  getPathParts,\n  getPropertyMembers,\n  getRelativePath,\n  getRoot,\n  getRunningActionContext,\n  getSnapshot,\n  getType,\n  hasParent,\n  hasParentOfType,\n  isActionContextChildOf,\n  isActionContextThisOrChildOf,\n  isAlive,\n  isArrayType,\n  isFrozenType,\n  isIdentifierType,\n  isLateType,\n  isLiteralType,\n  isMapType,\n  isModelType,\n  isOptionalType,\n  isPrimitiveType,\n  isProtected,\n  isReferenceType,\n  isRefinementType,\n  isRoot,\n  isStateTreeNode,\n  isType,\n  isUnionType,\n  isValidReference,\n  joinJsonPath,\n  onAction,\n  onPatch,\n  onSnapshot,\n  process,\n  protect,\n  recordActions,\n  recordPatches,\n  resolveIdentifier,\n  resolvePath,\n  setLivelinessChecking,\n  setLivelynessChecking,\n  splitJsonPath,\n  toGenerator,\n  toGeneratorFunction,\n  tryReference,\n  tryResolve,\n  typecheck,\n  types,\n  types as t,\n  unescapeJsonPath,\n  unprotect,\n  walk,\n  setDevMode\n} from \"./internal.ts\"\n"]}

package/esm/internal.d.ts

@@ -1,39 +0,0 @@
-export * from "./core/node/livelinessChecking.ts";
-export * from "./core/node/Hook.ts";
-export * from "./core/mst-operations.ts";
-export * from "./core/node/BaseNode.ts";
-export * from "./core/node/scalar-node.ts";
-export * from "./core/node/object-node.ts";
-export * from "./core/type/type.ts";
-export * from "./middlewares/create-action-tracking-middleware.ts";
-export * from "./middlewares/createActionTrackingMiddleware2.ts";
-export * from "./middlewares/on-action.ts";
-export * from "./core/action.ts";
-export * from "./core/actionContext.ts";
-export * from "./core/type/type-checker.ts";
-export * from "./core/node/identifier-cache.ts";
-export * from "./core/node/create-node.ts";
-export * from "./core/node/node-utils.ts";
-export * from "./core/process.ts";
-export * from "./core/flow.ts";
-export * from "./core/json-patch.ts";
-export * from "./utils.ts";
-export * from "./types/utility-types/snapshotProcessor.ts";
-export * from "./types/complex-types/map.ts";
-export * from "./types/complex-types/array.ts";
-export * from "./types/complex-types/model.ts";
-export * from "./types/primitives.ts";
-export * from "./types/utility-types/literal.ts";
-export * from "./types/utility-types/refinement.ts";
-export * from "./types/utility-types/enumeration.ts";
-export * from "./types/utility-types/union.ts";
-export * from "./types/utility-types/optional.ts";
-export * from "./types/utility-types/maybe.ts";
-export * from "./types/utility-types/late.ts";
-export * from "./types/utility-types/lazy.ts";
-export * from "./types/utility-types/frozen.ts";
-export * from "./types/utility-types/reference.ts";
-export * from "./types/utility-types/identifier.ts";
-export * from "./types/utility-types/custom.ts";
-export * from "./types/utility-types/resilient.ts";
-export * from "./types/index.ts";