@jbrowse/mobx-state-tree 5.7.1 → 5.8.7

package/esm/types/utility-types/frozen.js

@@ -1,92 +0,0 @@
-import { SimpleType } from "../../core/type/type.js";
-import { TypeFlags, createScalarNode, deepFreeze, isSerializable, isType, optional, typeCheckFailure, typeCheckSuccess } from "../../internal.js";
-/**
- * @internal
- * @hidden
- */
-export class Frozen extends SimpleType {
-    subType;
-    flags = TypeFlags.Frozen;
-    constructor(subType) {
-        super(subType ? `frozen(${subType.name})` : "frozen");
-        this.subType = subType;
-    }
-    describe() {
-        return "<any immutable value>";
-    }
-    instantiate(parent, subpath, environment, value) {
-        // create the node
-        return createScalarNode(this, parent, subpath, environment, deepFreeze(value));
-    }
-    isValidSnapshot(value, context) {
-        if (!isSerializable(value)) {
-            return typeCheckFailure(context, value, "Value is not serializable and cannot be frozen");
-        }
-        if (this.subType) {
-            return this.subType.validate(value, context);
-        }
-        return typeCheckSuccess();
-    }
-}
-const untypedFrozenInstance = new Frozen();
-/**
- * `types.frozen` - Frozen can be used to store any value that is serializable in itself (that is valid JSON).
- * Frozen values need to be immutable or treated as if immutable. They need be serializable as well.
- * Values stored in frozen will snapshotted as-is by MST, and internal changes will not be tracked.
- *
- * This is useful to store complex, but immutable values like vectors etc. It can form a powerful bridge to parts of your application that should be immutable, or that assume data to be immutable.
- *
- * Note: if you want to store free-form state that is mutable, or not serializeable, consider using volatile state instead.
- *
- * Frozen properties can be defined in three different ways
- * 1. `types.frozen(SubType)` - provide a valid MST type and frozen will check if the provided data conforms the snapshot for that type
- * 2. `types.frozen({ someDefaultValue: true})` - provide a primitive value, object or array, and MST will infer the type from that object, and also make it the default value for the field
- * 3. `types.frozen<TypeScriptType>()` - provide a typescript type, to help in strongly typing the field (design time only)
- *
- * Example:
- * ```ts
- * const GameCharacter = types.model({
- *   name: string,
- *   location: types.frozen({ x: 0, y: 0})
- * })
- *
- * const hero = GameCharacter.create({
- *   name: "Mario",
- *   location: { x: 7, y: 4 }
- * })
- *
- * hero.location = { x: 10, y: 2 } // OK
- * hero.location.x = 7 // Not ok!
- * ```
- *
- * ```ts
- * type Point = { x: number, y: number }
- *    const Mouse = types.model({
- *         loc: types.frozen<Point>()
- *    })
- * ```
- *
- * @param defaultValueOrType
- * @returns
- */
-export function frozen(arg) {
-    if (arguments.length === 0) {
-        return untypedFrozenInstance;
-    }
-    else if (isType(arg)) {
-        return new Frozen(arg);
-    }
-    else {
-        return optional(untypedFrozenInstance, arg);
-    }
-}
-/**
- * Returns if a given value represents a frozen type.
- *
- * @param type
- * @returns
- */
-export function isFrozenType(type) {
-    return isType(type) && (type.flags & TypeFlags.Frozen) > 0;
-}
-//# sourceMappingURL=frozen.js.map

package/esm/types/utility-types/frozen.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"frozen.js","sourceRoot":"","sources":["../../../src/types/utility-types/frozen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACpD,OAAO,EAML,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,MAAM,EACN,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,mBAAmB,CAAA;AAE1B;;;GAGG;AACH,MAAM,OAAO,MAAU,SAAQ,UAAmB;IAG5B;IAFpB,KAAK,GAAG,SAAS,CAAC,MAAM,CAAA;IAExB,YAAoB,OAAkB;QACpC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,OAAO,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAA;QADnC,YAAO,GAAP,OAAO,CAAW;IAEtC,CAAC;IAED,QAAQ;QACN,OAAO,uBAAuB,CAAA;IAChC,CAAC;IAED,WAAW,CACT,MAA4B,EAC5B,OAAe,EACf,WAAgB,EAChB,KAAgB;QAEhB,kBAAkB;QAClB,OAAO,gBAAgB,CACrB,IAAI,EACJ,MAAM,EACN,OAAO,EACP,WAAW,EACX,UAAU,CAAC,KAAK,CAAC,CAClB,CAAA;IACH,CAAC;IAED,eAAe,CACb,KAAgB,EAChB,OAA2B;QAE3B,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,gBAAgB,CACrB,OAAO,EACP,KAAK,EACL,gDAAgD,CACjD,CAAA;QACH,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAC9C,CAAC;QACD,OAAO,gBAAgB,EAAE,CAAA;IAC3B,CAAC;CACF;AAED,MAAM,qBAAqB,GAAG,IAAI,MAAM,EAAE,CAAA;AAK1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,UAAU,MAAM,CAAC,GAAS;IAC9B,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,qBAAqB,CAAA;IAC9B,CAAC;SAAM,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,CAAA;IACxB,CAAC;SAAM,CAAC;QACN,OAAO,QAAQ,CAAC,qBAAqB,EAAE,GAAG,CAAC,CAAA;IAC7C,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAQ;IAER,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;AAC5D,CAAC","sourcesContent":["import { SimpleType } from \"../../core/type/type.ts\"\nimport {\n  type AnyObjectNode,\n  type IAnyType,\n  type IType,\n  type IValidationContext,\n  type IValidationResult,\n  TypeFlags,\n  createScalarNode,\n  deepFreeze,\n  isSerializable,\n  isType,\n  optional,\n  typeCheckFailure,\n  typeCheckSuccess\n} from \"../../internal.ts\"\n\n/**\n * @internal\n * @hidden\n */\nexport class Frozen<T> extends SimpleType<T, T, T> {\n  flags = TypeFlags.Frozen\n\n  constructor(private subType?: IAnyType) {\n    super(subType ? `frozen(${subType.name})` : \"frozen\")\n  }\n\n  describe() {\n    return \"<any immutable value>\"\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    value: this[\"C\"]\n  ): this[\"N\"] {\n    // create the node\n    return createScalarNode(\n      this,\n      parent,\n      subpath,\n      environment,\n      deepFreeze(value)\n    )\n  }\n\n  isValidSnapshot(\n    value: this[\"C\"],\n    context: IValidationContext\n  ): IValidationResult {\n    if (!isSerializable(value)) {\n      return typeCheckFailure(\n        context,\n        value,\n        \"Value is not serializable and cannot be frozen\"\n      )\n    }\n    if (this.subType) {\n      return this.subType.validate(value, context)\n    }\n    return typeCheckSuccess()\n  }\n}\n\nconst untypedFrozenInstance = new Frozen()\n\nexport function frozen<C>(subType: IType<C, any, any>): IType<C, C, C>\nexport function frozen<T>(defaultValue: T): IType<T | undefined | null, T, T>\nexport function frozen<T = any>(): IType<T, T, T> // do not assume undefined by default, let the user specify it if needed\n/**\n * `types.frozen` - Frozen can be used to store any value that is serializable in itself (that is valid JSON).\n * Frozen values need to be immutable or treated as if immutable. They need be serializable as well.\n * Values stored in frozen will snapshotted as-is by MST, and internal changes will not be tracked.\n *\n * This is useful to store complex, but immutable values like vectors etc. It can form a powerful bridge to parts of your application that should be immutable, or that assume data to be immutable.\n *\n * Note: if you want to store free-form state that is mutable, or not serializeable, consider using volatile state instead.\n *\n * Frozen properties can be defined in three different ways\n * 1. `types.frozen(SubType)` - provide a valid MST type and frozen will check if the provided data conforms the snapshot for that type\n * 2. `types.frozen({ someDefaultValue: true})` - provide a primitive value, object or array, and MST will infer the type from that object, and also make it the default value for the field\n * 3. `types.frozen<TypeScriptType>()` - provide a typescript type, to help in strongly typing the field (design time only)\n *\n * Example:\n * ```ts\n * const GameCharacter = types.model({\n *   name: string,\n *   location: types.frozen({ x: 0, y: 0})\n * })\n *\n * const hero = GameCharacter.create({\n *   name: \"Mario\",\n *   location: { x: 7, y: 4 }\n * })\n *\n * hero.location = { x: 10, y: 2 } // OK\n * hero.location.x = 7 // Not ok!\n * ```\n *\n * ```ts\n * type Point = { x: number, y: number }\n *    const Mouse = types.model({\n *         loc: types.frozen<Point>()\n *    })\n * ```\n *\n * @param defaultValueOrType\n * @returns\n */\nexport function frozen(arg?: any): any {\n  if (arguments.length === 0) {\n    return untypedFrozenInstance\n  } else if (isType(arg)) {\n    return new Frozen(arg)\n  } else {\n    return optional(untypedFrozenInstance, arg)\n  }\n}\n\n/**\n * Returns if a given value represents a frozen type.\n *\n * @param type\n * @returns\n */\nexport function isFrozenType<IT extends IType<T | any, T, T>, T = any>(\n  type: IT\n): type is IT {\n  return isType(type) && (type.flags & TypeFlags.Frozen) > 0\n}\n"]}

package/esm/types/utility-types/identifier.d.ts

@@ -1,87 +0,0 @@
-import { SimpleType } from "../../core/type/type.ts";
-import { type AnyObjectNode, type ISimpleType, type IValidationContext, type IValidationResult, type ScalarNode, TypeFlags } from "../../internal.ts";
-declare abstract class BaseIdentifierType<T> extends SimpleType<T, T, T> {
-    private readonly validType;
-    readonly flags = TypeFlags.Identifier;
-    constructor(name: string, validType: "string" | "number");
-    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: this["C"]): this["N"];
-    reconcile(current: this["N"], newValue: this["C"], parent: AnyObjectNode, subpath: string): this["N"];
-    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
-}
-/**
- * @internal
- * @hidden
- */
-export declare class IdentifierType extends BaseIdentifierType<string> {
-    readonly flags = TypeFlags.Identifier;
-    constructor();
-    describe(): string;
-}
-/**
- * @internal
- * @hidden
- */
-export declare class IdentifierNumberType extends BaseIdentifierType<number> {
-    constructor();
-    getSnapshot(node: ScalarNode<number, number, number>): number;
-    describe(): string;
-}
-/**
- * `types.identifier` - Identifiers are used to make references, lifecycle events and reconciling works.
- * Inside a state tree, for each type can exist only one instance for each given identifier.
- * For example there couldn't be 2 instances of user with id 1. If you need more, consider using references.
- * Identifier can be used only as type property of a model.
- * This type accepts as parameter the value type of the identifier field that can be either string or number.
- *
- * Example:
- * ```ts
- *  const Todo = types.model("Todo", {
- *      id: types.identifier,
- *      title: types.string
- *  })
- * ```
- *
- * @returns
- */
-export declare const identifier: ISimpleType<string>;
-/**
- * `types.identifierNumber` - Similar to `types.identifier`. This one will serialize from / to a number when applying snapshots
- *
- * Example:
- * ```ts
- *  const Todo = types.model("Todo", {
- *      id: types.identifierNumber,
- *      title: types.string
- *  })
- * ```
- *
- * @returns
- */
-export declare const identifierNumber: ISimpleType<number>;
-/**
- * Returns if a given value represents an identifier type.
- *
- * @param type
- * @returns
- */
-export declare function isIdentifierType<IT extends typeof identifier | typeof identifierNumber>(type: IT): type is IT;
-/**
- * Valid types for identifiers.
- */
-export type ReferenceIdentifier = string | number;
-/**
- * @internal
- * @hidden
- */
-export declare function normalizeIdentifier(id: ReferenceIdentifier): string;
-/**
- * @internal
- * @hidden
- */
-export declare function isValidIdentifier(id: any): id is ReferenceIdentifier;
-/**
- * @internal
- * @hidden
- */
-export declare function assertIsValidIdentifier(id: ReferenceIdentifier, argNumber: number | number[]): void;
-export {};

package/esm/types/utility-types/identifier.js

@@ -1,121 +0,0 @@
-import { SimpleType } from "../../core/type/type.js";
-import { ModelType, TypeFlags, assertArg, createScalarNode, fail, isType, typeCheckFailure, typeCheckSuccess } from "../../internal.js";
-class BaseIdentifierType extends SimpleType {
-    validType;
-    flags = TypeFlags.Identifier;
-    constructor(name, validType) {
-        super(name);
-        this.validType = validType;
-    }
-    instantiate(parent, subpath, environment, initialValue) {
-        if (!parent || !(parent.type instanceof ModelType)) {
-            throw fail(`Identifier types can only be instantiated as direct child of a model type`);
-        }
-        return createScalarNode(this, parent, subpath, environment, initialValue);
-    }
-    reconcile(current, newValue, parent, subpath) {
-        // we don't consider detaching here since identifier are scalar nodes, and scalar nodes cannot be detached
-        if (current.storedValue !== newValue) {
-            throw fail(`Tried to change identifier from '${current.storedValue}' to '${newValue}'. Changing identifiers is not allowed.`);
-        }
-        current.setParent(parent, subpath);
-        return current;
-    }
-    isValidSnapshot(value, context) {
-        if (typeof value !== this.validType) {
-            return typeCheckFailure(context, value, `Value is not a valid ${this.describe()}, expected a ${this.validType}`);
-        }
-        return typeCheckSuccess();
-    }
-}
-/**
- * @internal
- * @hidden
- */
-export class IdentifierType extends BaseIdentifierType {
-    flags = TypeFlags.Identifier;
-    constructor() {
-        super(`identifier`, "string");
-    }
-    describe() {
-        return `identifier`;
-    }
-}
-/**
- * @internal
- * @hidden
- */
-export class IdentifierNumberType extends BaseIdentifierType {
-    constructor() {
-        super("identifierNumber", "number");
-    }
-    getSnapshot(node) {
-        return node.storedValue;
-    }
-    describe() {
-        return `identifierNumber`;
-    }
-}
-/**
- * `types.identifier` - Identifiers are used to make references, lifecycle events and reconciling works.
- * Inside a state tree, for each type can exist only one instance for each given identifier.
- * For example there couldn't be 2 instances of user with id 1. If you need more, consider using references.
- * Identifier can be used only as type property of a model.
- * This type accepts as parameter the value type of the identifier field that can be either string or number.
- *
- * Example:
- * ```ts
- *  const Todo = types.model("Todo", {
- *      id: types.identifier,
- *      title: types.string
- *  })
- * ```
- *
- * @returns
- */
-export const identifier = new IdentifierType();
-/**
- * `types.identifierNumber` - Similar to `types.identifier`. This one will serialize from / to a number when applying snapshots
- *
- * Example:
- * ```ts
- *  const Todo = types.model("Todo", {
- *      id: types.identifierNumber,
- *      title: types.string
- *  })
- * ```
- *
- * @returns
- */
-export const identifierNumber = new IdentifierNumberType();
-/**
- * Returns if a given value represents an identifier type.
- *
- * @param type
- * @returns
- */
-export function isIdentifierType(type) {
-    return isType(type) && (type.flags & TypeFlags.Identifier) > 0;
-}
-/**
- * @internal
- * @hidden
- */
-export function normalizeIdentifier(id) {
-    return "" + id;
-}
-/**
- * @internal
- * @hidden
- */
-export function isValidIdentifier(id) {
-    return typeof id === "string" || typeof id === "number";
-}
-/**
- * @internal
- * @hidden
- */
-export function assertIsValidIdentifier(id, argNumber) {
-    assertArg(id, isValidIdentifier, "string or number (identifier)", argNumber);
-}
-//# sourceMappingURL=identifier.js.map

package/esm/types/utility-types/identifier.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"identifier.js","sourceRoot":"","sources":["../../../src/types/utility-types/identifier.ts"],"names":[],"mappings":"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","sourcesContent":["import { SimpleType } from \"../../core/type/type.ts\"\nimport {\n  type AnyObjectNode,\n  type ISimpleType,\n  type IValidationContext,\n  type IValidationResult,\n  ModelType,\n  type ScalarNode,\n  TypeFlags,\n  assertArg,\n  createScalarNode,\n  fail,\n  isType,\n  typeCheckFailure,\n  typeCheckSuccess\n} from \"../../internal.ts\"\n\nabstract class BaseIdentifierType<T> extends SimpleType<T, T, T> {\n  readonly flags = TypeFlags.Identifier\n\n  constructor(\n    name: string,\n    private readonly validType: \"string\" | \"number\"\n  ) {\n    super(name)\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: this[\"C\"]\n  ): this[\"N\"] {\n    if (!parent || !(parent.type instanceof ModelType)) {\n      throw fail(\n        `Identifier types can only be instantiated as direct child of a model type`\n      )\n    }\n\n    return createScalarNode(this, parent, subpath, environment, initialValue)\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    newValue: this[\"C\"],\n    parent: AnyObjectNode,\n    subpath: string\n  ) {\n    // we don't consider detaching here since identifier are scalar nodes, and scalar nodes cannot be detached\n    if (current.storedValue !== newValue) {\n      throw fail(\n        `Tried to change identifier from '${current.storedValue}' to '${newValue}'. Changing identifiers is not allowed.`\n      )\n    }\n    current.setParent(parent, subpath)\n    return current\n  }\n\n  isValidSnapshot(\n    value: this[\"C\"],\n    context: IValidationContext\n  ): IValidationResult {\n    if (typeof value !== this.validType) {\n      return typeCheckFailure(\n        context,\n        value,\n        `Value is not a valid ${this.describe()}, expected a ${this.validType}`\n      )\n    }\n    return typeCheckSuccess()\n  }\n}\n\n/**\n * @internal\n * @hidden\n */\nexport class IdentifierType extends BaseIdentifierType<string> {\n  readonly flags = TypeFlags.Identifier\n\n  constructor() {\n    super(`identifier`, \"string\")\n  }\n\n  describe() {\n    return `identifier`\n  }\n}\n\n/**\n * @internal\n * @hidden\n */\nexport class IdentifierNumberType extends BaseIdentifierType<number> {\n  constructor() {\n    super(\"identifierNumber\", \"number\")\n  }\n\n  getSnapshot(node: ScalarNode<number, number, number>): number {\n    return node.storedValue\n  }\n\n  describe() {\n    return `identifierNumber`\n  }\n}\n\n/**\n * `types.identifier` - Identifiers are used to make references, lifecycle events and reconciling works.\n * Inside a state tree, for each type can exist only one instance for each given identifier.\n * For example there couldn't be 2 instances of user with id 1. If you need more, consider using references.\n * Identifier can be used only as type property of a model.\n * This type accepts as parameter the value type of the identifier field that can be either string or number.\n *\n * Example:\n * ```ts\n *  const Todo = types.model(\"Todo\", {\n *      id: types.identifier,\n *      title: types.string\n *  })\n * ```\n *\n * @returns\n */\nexport const identifier: ISimpleType<string> = new IdentifierType()\n\n/**\n * `types.identifierNumber` - Similar to `types.identifier`. This one will serialize from / to a number when applying snapshots\n *\n * Example:\n * ```ts\n *  const Todo = types.model(\"Todo\", {\n *      id: types.identifierNumber,\n *      title: types.string\n *  })\n * ```\n *\n * @returns\n */\nexport const identifierNumber: ISimpleType<number> = new IdentifierNumberType()\n\n/**\n * Returns if a given value represents an identifier type.\n *\n * @param type\n * @returns\n */\nexport function isIdentifierType<\n  IT extends typeof identifier | typeof identifierNumber\n>(type: IT): type is IT {\n  return isType(type) && (type.flags & TypeFlags.Identifier) > 0\n}\n\n/**\n * Valid types for identifiers.\n */\nexport type ReferenceIdentifier = string | number\n\n/**\n * @internal\n * @hidden\n */\nexport function normalizeIdentifier(id: ReferenceIdentifier): string {\n  return \"\" + id\n}\n\n/**\n * @internal\n * @hidden\n */\nexport function isValidIdentifier(id: any): id is ReferenceIdentifier {\n  return typeof id === \"string\" || typeof id === \"number\"\n}\n\n/**\n * @internal\n * @hidden\n */\nexport function assertIsValidIdentifier(\n  id: ReferenceIdentifier,\n  argNumber: number | number[]\n) {\n  assertArg(id, isValidIdentifier, \"string or number (identifier)\", argNumber)\n}\n"]}

package/esm/types/utility-types/late.d.ts

@@ -1,10 +0,0 @@
-import { type IAnyType } from "../../internal.ts";
-export declare function late<T extends IAnyType>(type: () => T): T;
-export declare function late<T extends IAnyType>(name: string, type: () => T): T;
-/**
- * Returns if a given value represents a late type.
- *
- * @param type
- * @returns
- */
-export declare function isLateType<IT extends IAnyType>(type: IT): type is IT;

package/esm/types/utility-types/late.js

@@ -1,106 +0,0 @@
-import { BaseType } from "../../core/type/type.js";
-import { TypeFlags, cannotDetermineSubtype, devMode, fail, isType, typeCheckSuccess } from "../../internal.js";
-class Late extends BaseType {
-    _definition;
-    _subType;
-    get flags() {
-        return (this._subType ? this._subType.flags : 0) | TypeFlags.Late;
-    }
-    getSubType(mustSucceed) {
-        if (!this._subType) {
-            let t = undefined;
-            try {
-                t = this._definition();
-            }
-            catch (e) {
-                if (e instanceof ReferenceError) // can happen in strict ES5 code when a definition is self refering
-                 {
-                    t = undefined;
-                }
-                else {
-                    throw e;
-                }
-            }
-            if (mustSucceed && t === undefined) {
-                throw fail("Late type seems to be used too early, the definition (still) returns undefined");
-            }
-            if (t) {
-                if (devMode() && !isType(t)) {
-                    throw fail("Failed to determine subtype, make sure types.late returns a type definition.");
-                }
-                this._subType = t;
-            }
-        }
-        return this._subType;
-    }
-    constructor(name, _definition) {
-        super(name);
-        this._definition = _definition;
-    }
-    instantiate(parent, subpath, environment, initialValue) {
-        return this.getSubType(true).instantiate(parent, subpath, environment, initialValue);
-    }
-    reconcile(current, newValue, parent, subpath) {
-        return this.getSubType(true).reconcile(current, newValue, parent, subpath);
-    }
-    describe() {
-        const t = this.getSubType(false);
-        return t ? t.name : "<uknown late type>";
-    }
-    isValidSnapshot(value, context) {
-        const t = this.getSubType(false);
-        if (!t) {
-            // See #916; the variable the definition closure is pointing to wasn't defined yet, so can't be evaluted yet here
-            return typeCheckSuccess();
-        }
-        return t.validate(value, context);
-    }
-    isAssignableFrom(type) {
-        const t = this.getSubType(false);
-        return t ? t.isAssignableFrom(type) : false;
-    }
-    getSubTypes() {
-        const subtype = this.getSubType(false);
-        return subtype ? subtype : cannotDetermineSubtype;
-    }
-}
-/**
- * `types.late` - Defines a type that gets implemented later. This is useful when you have to deal with circular dependencies.
- * Please notice that when defining circular dependencies TypeScript isn't smart enough to inference them.
- *
- * Example:
- * ```ts
- *   // TypeScript isn't smart enough to infer self referencing types.
- *  const Node = types.model({
- *       children: types.array(types.late((): IAnyModelType => Node)) // then typecast each array element to Instance<typeof Node>
- *  })
- * ```
- *
- * @param name The name to use for the type that will be returned.
- * @param type A function that returns the type that will be defined.
- * @returns
- */
-export function late(nameOrType, maybeType) {
-    const name = typeof nameOrType === "string"
-        ? nameOrType
-        : `late(${nameOrType.toString()})`;
-    const type = typeof nameOrType === "string" ? maybeType : nameOrType;
-    // checks that the type is actually a late type
-    if (devMode()) {
-        if (!(typeof type === "function" && type.length === 0)) {
-            throw fail("Invalid late type, expected a function with zero arguments that returns a type, got: " +
-                type);
-        }
-    }
-    return new Late(name, type);
-}
-/**
- * Returns if a given value represents a late type.
- *
- * @param type
- * @returns
- */
-export function isLateType(type) {
-    return isType(type) && (type.flags & TypeFlags.Late) > 0;
-}
-//# sourceMappingURL=late.js.map

package/esm/types/utility-types/late.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"late.js","sourceRoot":"","sources":["../../../src/types/utility-types/late.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseType } from \"../../core/type/type.ts\"\nimport {\n  type AnyObjectNode,\n  type ExtractNodeType,\n  type IAnyType,\n  type IValidationContext,\n  type IValidationResult,\n  TypeFlags,\n  cannotDetermineSubtype,\n  devMode,\n  fail,\n  isType,\n  typeCheckSuccess\n} from \"../../internal.ts\"\n\nclass Late<IT extends IAnyType> extends BaseType<\n  IT[\"CreationType\"],\n  IT[\"SnapshotType\"],\n  IT[\"TypeWithoutSTN\"],\n  ExtractNodeType<IT>\n> {\n  private _subType?: IT\n\n  get flags() {\n    return (this._subType ? this._subType.flags : 0) | TypeFlags.Late\n  }\n\n  getSubType(mustSucceed: true): IT\n  getSubType(mustSucceed: false): IT | undefined\n  getSubType(mustSucceed: boolean): IT | undefined {\n    if (!this._subType) {\n      let t = undefined\n      try {\n        t = this._definition()\n      } catch (e) {\n        if (\n          e instanceof ReferenceError\n        ) // can happen in strict ES5 code when a definition is self refering\n        {\n          t = undefined\n        } else {\n          throw e\n        }\n      }\n      if (mustSucceed && t === undefined) {\n        throw fail(\n          \"Late type seems to be used too early, the definition (still) returns undefined\"\n        )\n      }\n      if (t) {\n        if (devMode() && !isType(t)) {\n          throw fail(\n            \"Failed to determine subtype, make sure types.late returns a type definition.\"\n          )\n        }\n        this._subType = t\n      }\n    }\n    return this._subType\n  }\n\n  constructor(\n    name: string,\n    private readonly _definition: () => IT\n  ) {\n    super(name)\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 this.getSubType(true).instantiate(\n      parent,\n      subpath,\n      environment,\n      initialValue\n    ) as any\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    newValue: this[\"C\"] | this[\"T\"],\n    parent: AnyObjectNode,\n    subpath: string\n  ): this[\"N\"] {\n    return this.getSubType(true).reconcile(\n      current,\n      newValue,\n      parent,\n      subpath\n    ) as any\n  }\n\n  describe() {\n    const t = this.getSubType(false)\n    return t ? t.name : \"<uknown late type>\"\n  }\n\n  isValidSnapshot(\n    value: this[\"C\"],\n    context: IValidationContext\n  ): IValidationResult {\n    const t = this.getSubType(false)\n    if (!t) {\n      // See #916; the variable the definition closure is pointing to wasn't defined yet, so can't be evaluted yet here\n      return typeCheckSuccess()\n    }\n    return t.validate(value, context)\n  }\n\n  isAssignableFrom(type: IAnyType) {\n    const t = this.getSubType(false)\n    return t ? t.isAssignableFrom(type) : false\n  }\n\n  getSubTypes() {\n    const subtype = this.getSubType(false)\n    return subtype ? subtype : cannotDetermineSubtype\n  }\n}\n\nexport function late<T extends IAnyType>(type: () => T): T\nexport function late<T extends IAnyType>(name: string, type: () => T): T\n/**\n * `types.late` - Defines a type that gets implemented later. This is useful when you have to deal with circular dependencies.\n * Please notice that when defining circular dependencies TypeScript isn't smart enough to inference them.\n *\n * Example:\n * ```ts\n *   // TypeScript isn't smart enough to infer self referencing types.\n *  const Node = types.model({\n *       children: types.array(types.late((): IAnyModelType => Node)) // then typecast each array element to Instance<typeof Node>\n *  })\n * ```\n *\n * @param name The name to use for the type that will be returned.\n * @param type A function that returns the type that will be defined.\n * @returns\n */\nexport function late(nameOrType: any, maybeType?: () => IAnyType): IAnyType {\n  const name =\n    typeof nameOrType === \"string\"\n      ? nameOrType\n      : `late(${nameOrType.toString()})`\n  const type = typeof nameOrType === \"string\" ? maybeType : nameOrType\n  // checks that the type is actually a late type\n  if (devMode()) {\n    if (!(typeof type === \"function\" && type.length === 0)) {\n      throw fail(\n        \"Invalid late type, expected a function with zero arguments that returns a type, got: \" +\n          type\n      )\n    }\n  }\n  return new Late(name, type)\n}\n\n/**\n * Returns if a given value represents a late type.\n *\n * @param type\n * @returns\n */\nexport function isLateType<IT extends IAnyType>(type: IT): type is IT {\n  return isType(type) && (type.flags & TypeFlags.Late) > 0\n}\n"]}

package/esm/types/utility-types/lazy.d.ts

@@ -1,23 +0,0 @@
-import { SimpleType } from "../../core/type/type.ts";
-import { type AnyObjectNode, type IType, type IValidationContext, type IValidationResult, TypeFlags } from "../../internal.ts";
-interface LazyOptions<T extends IType<any, any, any>, U> {
-    loadType: () => Promise<T>;
-    shouldLoadPredicate: (parent: U) => boolean;
-}
-export declare function lazy<T extends IType<any, any, any>, U>(name: string, options: LazyOptions<T, U>): T;
-/**
- * @internal
- * @hidden
- */
-export declare class Lazy<T extends IType<any, any, any>, U> extends SimpleType<T, T, T> {
-    private readonly options;
-    flags: TypeFlags;
-    private loadedType;
-    private pendingNodeList;
-    constructor(name: string, options: LazyOptions<T, U>);
-    describe(): string;
-    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, value: this["C"]): this["N"];
-    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
-    reconcile(current: this["N"], value: T, parent: AnyObjectNode, subpath: string): this["N"];
-}
-export {};

package/esm/types/utility-types/lazy.js

@@ -1,72 +0,0 @@
-import { action, observable, when } from "mobx";
-import { SimpleType } from "../../core/type/type.js";
-import { TypeFlags, createScalarNode, deepFreeze, isSerializable, typeCheckFailure, typeCheckSuccess } from "../../internal.js";
-export function lazy(name, options) {
-    // TODO: fix this unknown casting to be stricter
-    return new Lazy(name, options);
-}
-/**
- * @internal
- * @hidden
- */
-export class Lazy extends SimpleType {
-    options;
-    flags = TypeFlags.Lazy;
-    loadedType = null;
-    pendingNodeList = observable.array();
-    constructor(name, options) {
-        super(name);
-        this.options = options;
-        when(() => this.pendingNodeList.length > 0 &&
-            this.pendingNodeList.some(node => node.isAlive &&
-                this.options.shouldLoadPredicate(node.parent ? node.parent.value : null)), () => {
-            this.options.loadType().then(action((type) => {
-                this.loadedType = type;
-                this.pendingNodeList.forEach(node => {
-                    if (!node.parent) {
-                        return;
-                    }
-                    if (!this.loadedType) {
-                        return;
-                    }
-                    node.parent.applyPatches([
-                        {
-                            op: "replace",
-                            path: `/${node.subpath}`,
-                            value: node.snapshot
-                        }
-                    ]);
-                });
-            }));
-        });
-    }
-    describe() {
-        return `<lazy ${this.name}>`;
-    }
-    instantiate(parent, subpath, environment, value) {
-        if (this.loadedType) {
-            return this.loadedType.instantiate(parent, subpath, environment, value);
-        }
-        const node = createScalarNode(this, parent, subpath, environment, deepFreeze(value));
-        this.pendingNodeList.push(node);
-        when(() => !node.isAlive, () => this.pendingNodeList.splice(this.pendingNodeList.indexOf(node), 1));
-        return node;
-    }
-    isValidSnapshot(value, context) {
-        if (this.loadedType) {
-            return this.loadedType.validate(value, context);
-        }
-        if (!isSerializable(value)) {
-            return typeCheckFailure(context, value, "Value is not serializable and cannot be lazy");
-        }
-        return typeCheckSuccess();
-    }
-    reconcile(current, value, parent, subpath) {
-        if (this.loadedType) {
-            current.die();
-            return this.loadedType.instantiate(parent, subpath, parent.environment, value);
-        }
-        return super.reconcile(current, value, parent, subpath);
-    }
-}
-//# sourceMappingURL=lazy.js.map

package/esm/types/utility-types/lazy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazy.js","sourceRoot":"","sources":["../../../src/types/utility-types/lazy.ts"],"names":[],"mappings":"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","sourcesContent":["import { type IObservableArray, action, observable, when } from \"mobx\"\n\nimport { SimpleType } from \"../../core/type/type.ts\"\nimport {\n  type AnyNode,\n  type AnyObjectNode,\n  type IType,\n  type IValidationContext,\n  type IValidationResult,\n  TypeFlags,\n  createScalarNode,\n  deepFreeze,\n  isSerializable,\n  typeCheckFailure,\n  typeCheckSuccess\n} from \"../../internal.ts\"\n\ninterface LazyOptions<T extends IType<any, any, any>, U> {\n  loadType: () => Promise<T>\n  shouldLoadPredicate: (parent: U) => boolean\n}\n\nexport function lazy<T extends IType<any, any, any>, U>(\n  name: string,\n  options: LazyOptions<T, U>\n): T {\n  // TODO: fix this unknown casting to be stricter\n  return new Lazy(name, options) as unknown as T\n}\n\n/**\n * @internal\n * @hidden\n */\nexport class Lazy<T extends IType<any, any, any>, U> extends SimpleType<\n  T,\n  T,\n  T\n> {\n  flags = TypeFlags.Lazy\n\n  private loadedType: T | null = null\n  private pendingNodeList: IObservableArray<AnyNode> = observable.array()\n\n  constructor(\n    name: string,\n    private readonly options: LazyOptions<T, U>\n  ) {\n    super(name)\n\n    when(\n      () =>\n        this.pendingNodeList.length > 0 &&\n        this.pendingNodeList.some(\n          node =>\n            node.isAlive &&\n            this.options.shouldLoadPredicate(\n              node.parent ? node.parent.value : null\n            )\n        ),\n      () => {\n        this.options.loadType().then(\n          action((type: T) => {\n            this.loadedType = type\n            this.pendingNodeList.forEach(node => {\n              if (!node.parent) {\n                return\n              }\n              if (!this.loadedType) {\n                return\n              }\n\n              node.parent.applyPatches([\n                {\n                  op: \"replace\",\n                  path: `/${node.subpath}`,\n                  value: node.snapshot\n                }\n              ])\n            })\n          })\n        )\n      }\n    )\n  }\n\n  describe() {\n    return `<lazy ${this.name}>`\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    value: this[\"C\"]\n  ): this[\"N\"] {\n    if (this.loadedType) {\n      return this.loadedType.instantiate(\n        parent,\n        subpath,\n        environment,\n        value\n      ) as this[\"N\"]\n    }\n\n    const node = createScalarNode(\n      this,\n      parent,\n      subpath,\n      environment,\n      deepFreeze(value)\n    )\n    this.pendingNodeList.push(node)\n\n    when(\n      () => !node.isAlive,\n      () => this.pendingNodeList.splice(this.pendingNodeList.indexOf(node), 1)\n    )\n\n    return node\n  }\n\n  isValidSnapshot(\n    value: this[\"C\"],\n    context: IValidationContext\n  ): IValidationResult {\n    if (this.loadedType) {\n      return this.loadedType.validate(value, context)\n    }\n    if (!isSerializable(value)) {\n      return typeCheckFailure(\n        context,\n        value,\n        \"Value is not serializable and cannot be lazy\"\n      )\n    }\n    return typeCheckSuccess()\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    value: T,\n    parent: AnyObjectNode,\n    subpath: string\n  ): this[\"N\"] {\n    if (this.loadedType) {\n      current.die()\n      return this.loadedType.instantiate(\n        parent,\n        subpath,\n        parent.environment,\n        value\n      ) as this[\"N\"]\n    }\n    return super.reconcile(current, value, parent, subpath)\n  }\n}\n"]}

package/esm/types/utility-types/literal.d.ts

@@ -1,38 +0,0 @@
-import { SimpleType } from "../../core/type/type.ts";
-import { type AnyObjectNode, type ISimpleType, type IValidationContext, type IValidationResult, type Primitives, TypeFlags } from "../../internal.ts";
-/**
- * @internal
- * @hidden
- */
-export declare class Literal<T> extends SimpleType<T, T, T> {
-    readonly value: T;
-    readonly flags = TypeFlags.Literal;
-    constructor(value: T);
-    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: this["C"]): this["N"];
-    describe(): string;
-    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
-}
-/**
- * `types.literal` - The literal type will return a type that will match only the exact given type.
- * The given value must be a primitive, in order to be serialized to a snapshot correctly.
- * You can use literal to match exact strings for example the exact male or female string.
- *
- * Example:
- * ```ts
- * const Person = types.model({
- *     name: types.string,
- *     gender: types.union(types.literal('male'), types.literal('female'))
- * })
- * ```
- *
- * @param value The value to use in the strict equal check
- * @returns
- */
-export declare function literal<S extends Primitives>(value: S): ISimpleType<S>;
-/**
- * Returns if a given value represents a literal type.
- *
- * @param type
- * @returns
- */
-export declare function isLiteralType<IT extends ISimpleType<any>>(type: IT): type is IT;