@jbrowse/mobx-state-tree 5.6.3 → 5.6.6

package/dist/core/type/type.d.ts

@@ -0,0 +1,317 @@
+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/dist/core/type/type.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleType = exports.ComplexType = exports.BaseType = exports.cannotDetermineSubtype = exports.TypeFlags = void 0;
+exports.isType = isType;
+exports.assertIsType = assertIsType;
+const mobx_1 = require("mobx");
+const internal_ts_1 = require("../../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
+ */
+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 || (exports.TypeFlags = TypeFlags = {}));
+/**
+ * @internal
+ * @hidden
+ */
+exports.cannotDetermineSubtype = "cannotDetermine";
+/** @hidden */
+const $type = Symbol("$type");
+/**
+ * A base type produces a MST node (Node in the state tree)
+ *
+ * @internal
+ * @hidden
+ */
+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) {
+        (0, internal_ts_1.typecheckInternal)(this, snapshot);
+        return this.instantiate(null, "", environment, snapshot).value;
+    }
+    getSnapshot(_node, _applyPostProcess) {
+        // istanbul ignore next
+        throw (0, internal_ts_1.fail)("unimplemented method");
+    }
+    isAssignableFrom(type) {
+        return type === this;
+    }
+    validate(value, context) {
+        const node = (0, internal_ts_1.getStateTreeNodeSafe)(value);
+        if (node) {
+            const valueType = (0, internal_ts_1.getType)(value);
+            return this.isAssignableFrom(valueType)
+                ? (0, internal_ts_1.typeCheckSuccess)()
+                : (0, internal_ts_1.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 (0, internal_ts_1.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 (0, internal_ts_1.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 (0, internal_ts_1.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 (0, internal_ts_1.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`");
+    }
+}
+exports.BaseType = BaseType;
+BaseType.prototype.create = (0, mobx_1.action)(BaseType.prototype.create);
+/**
+ * A complex type produces a MST node (Node in the state tree)
+ *
+ * @internal
+ * @hidden
+ */
+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 ===
+                (0, internal_ts_1.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 ((0, internal_ts_1.isStateTreeNode)(newValue) && (0, internal_ts_1.getStateTreeNode)(newValue) === current) {
+            // the current node is the same as the new one
+            return true;
+        }
+        if (current.type === this &&
+            (0, internal_ts_1.isMutable)(newValue) &&
+            !(0, internal_ts_1.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 ((0, internal_ts_1.isStateTreeNode)(newValue) && this.isAssignableFrom((0, internal_ts_1.getType)(newValue))) {
+            // newValue is a Node as well, move it here..
+            const newNode = (0, internal_ts_1.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;
+    }
+}
+exports.ComplexType = ComplexType;
+ComplexType.prototype.create = (0, mobx_1.action)(ComplexType.prototype.create);
+/**
+ * @internal
+ * @hidden
+ */
+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;
+    }
+}
+exports.SimpleType = SimpleType;
+/**
+ * Returns if a given value represents a type.
+ *
+ * @param value Value to check.
+ * @returns `true` if the value is a type.
+ */
+function isType(value) {
+    return typeof value === "object" && value && value.isType === true;
+}
+/**
+ * @internal
+ * @hidden
+ */
+function assertIsType(type, argNumber) {
+    (0, internal_ts_1.assertArg)(type, isType, "mobx-state-tree type", argNumber);
+}
+//# sourceMappingURL=type.js.map

package/dist/core/type/type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.js","sourceRoot":"","sources":["../../../src/core/type/type.ts"],"names":[],"mappings":";;;AAinBA,wBAEC;AAMD,oCAEC;AA3nBD,+BAA6B;AAE7B,mDAa0B;AAE1B,4FAA4F;AAC5F,0DAA0D;AAC1D,MAAM,eAAe,GAAG,IAAI,OAAO,EAGhC,CAAA;AAeH;;;GAGG;AACH,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,yBAAT,SAAS,QAwBpB;AAED;;;GAGG;AACU,QAAA,sBAAsB,GAAG,iBAAiB,CAAA;AAUvD,cAAc;AACd,MAAM,KAAK,GAAkB,MAAM,CAAC,OAAO,CAAC,CAAA;AA2N5C;;;;;GAKG;AACH,MAAsB,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,IAAA,+BAAiB,EAAC,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,IAAA,kBAAI,EAAC,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,IAAA,kCAAoB,EAAC,KAAK,CAAC,CAAA;QACxC,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,SAAS,GAAG,IAAA,qBAAO,EAAC,KAAK,CAAC,CAAA;YAChC,OAAO,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC;gBACrC,CAAC,CAAC,IAAA,8BAAgB,GAAE;gBACpB,CAAC,CAAC,IAAA,8BAAgB,EAAC,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,IAAA,kBAAI,EACR,uJAAuJ,CACxJ,CAAA;IACH,CAAC;IACD,IAAI,cAAc;QAChB,uBAAuB;QACvB,MAAM,IAAA,kBAAI,EACR,2KAA2K,CAC5K,CAAA;IACH,CAAC;IACD,IAAI,YAAY;QACd,uBAAuB;QACvB,MAAM,IAAA,kBAAI,EACR,uKAAuK,CACxK,CAAA;IACH,CAAC;IACD,IAAI,YAAY;QACd,uBAAuB;QACvB,MAAM,IAAA,kBAAI,EACR,uKAAuK,CACxK,CAAA;IACH,CAAC;CAOF;AA/HD,4BA+HC;AACD,QAAQ,CAAC,SAAS,CAAC,MAAM,GAAG,IAAA,aAAM,EAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;AAe7D;;;;;GAKG;AACH,MAAsB,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,IAAA,iCAAmB,EAAE,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,IAAA,6BAAe,EAAC,QAAQ,CAAC,IAAI,IAAA,8BAAgB,EAAC,QAAQ,CAAC,KAAK,OAAO,EAAE,CAAC;YACxE,8CAA8C;YAC9C,OAAO,IAAI,CAAA;QACb,CAAC;QACD,IACE,OAAO,CAAC,IAAI,KAAK,IAAI;YACrB,IAAA,uBAAS,EAAC,QAAQ,CAAC;YACnB,CAAC,IAAA,6BAAe,EAAC,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,IAAA,6BAAe,EAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAA,qBAAO,EAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;YAC1E,6CAA6C;YAC7C,MAAM,OAAO,GAAG,IAAA,8BAAgB,EAAC,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;AAtGD,kCAsGC;AACD,WAAW,CAAC,SAAS,CAAC,MAAM,GAAG,IAAA,aAAM,EAAC,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;AAEnE;;;GAGG;AACH,MAAsB,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;AApDD,gCAoDC;AAED;;;;;GAKG;AACH,SAAgB,MAAM,CAAC,KAAU;IAC/B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAA;AACpE,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,IAAc,EAAE,SAA4B;IACvE,IAAA,uBAAS,EAAC,IAAI,EAAE,MAAM,EAAE,sBAAsB,EAAE,SAAS,CAAC,CAAA;AAC5D,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+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 } 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";