@jbrowse/mobx-state-tree 5.6.3 → 5.6.6

package/dist/types/primitives.d.ts

@@ -0,0 +1,124 @@
+import { SimpleType, TypeFlags } from "../internal.ts";
+import type { AnyObjectNode, ISimpleType, IType, IValidationContext, IValidationResult } from "../internal.ts";
+/**
+ * @internal
+ * @hidden
+ */
+export declare class CoreType<C, S, T> extends SimpleType<C, S, T> {
+    readonly flags: TypeFlags;
+    private readonly checker;
+    private readonly initializer;
+    constructor(name: string, flags: TypeFlags, checker: (value: C) => boolean, initializer?: (v: C) => T);
+    describe(): string;
+    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: C): this["N"];
+    createNewInstance(snapshot: C): T;
+    isValidSnapshot(value: C, context: IValidationContext): IValidationResult;
+}
+/**
+ * `types.string` - Creates a type that can only contain a string value.
+ * This type is used for string values by default
+ *
+ * Example:
+ * ```ts
+ * const Person = types.model({
+ *   firstName: types.string,
+ *   lastName: "Doe"
+ * })
+ * ```
+ */
+export declare const string: ISimpleType<string>;
+/**
+ * `types.number` - Creates a type that can only contain a numeric value.
+ * This type is used for numeric values by default
+ *
+ * Example:
+ * ```ts
+ * const Vector = types.model({
+ *   x: types.number,
+ *   y: 1.5
+ * })
+ * ```
+ */
+export declare const number: ISimpleType<number>;
+/**
+ * `types.integer` - Creates a type that can only contain an integer value.
+ *
+ * Example:
+ * ```ts
+ * const Size = types.model({
+ *   width: types.integer,
+ *   height: 10
+ * })
+ * ```
+ */
+export declare const integer: ISimpleType<number>;
+/**
+ * `types.float` - Creates a type that can only contain an float value.
+ *
+ * Example:
+ * ```ts
+ * const Size = types.model({
+ *   width: types.float,
+ *   height: 10
+ * })
+ * ```
+ */
+export declare const float: ISimpleType<number>;
+/**
+ * `types.finite` - Creates a type that can only contain an finite value.
+ *
+ * Example:
+ * ```ts
+ * const Size = types.model({
+ *   width: types.finite,
+ *   height: 10
+ * })
+ * ```
+ */
+export declare const finite: ISimpleType<number>;
+/**
+ * `types.boolean` - Creates a type that can only contain a boolean value.
+ * This type is used for boolean values by default
+ *
+ * Example:
+ * ```ts
+ * const Thing = types.model({
+ *   isCool: types.boolean,
+ *   isAwesome: false
+ * })
+ * ```
+ */
+export declare const boolean: ISimpleType<boolean>;
+/**
+ * `types.null` - The type of the value `null`
+ */
+export declare const nullType: ISimpleType<null>;
+/**
+ * `types.undefined` - The type of the value `undefined`
+ */
+export declare const undefinedType: ISimpleType<undefined>;
+/**
+ * `types.Date` - Creates a type that can only contain a javascript Date value.
+ *
+ * Example:
+ * ```ts
+ * const LogLine = types.model({
+ *   timestamp: types.Date,
+ * })
+ *
+ * LogLine.create({ timestamp: new Date() })
+ * ```
+ */
+export declare const DatePrimitive: IType<number | Date, number, Date>;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function getPrimitiveFactoryFromValue(value: any): ISimpleType<any>;
+/**
+ * Returns if a given value represents a primitive type.
+ *
+ * @param type
+ * @returns
+ */
+export declare function isPrimitiveType<IT extends ISimpleType<string> | ISimpleType<number> | ISimpleType<boolean> | typeof DatePrimitive>(type: IT): type is IT;

package/dist/types/primitives.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatePrimitive = exports.undefinedType = exports.nullType = exports.boolean = exports.finite = exports.float = exports.integer = exports.number = exports.string = exports.CoreType = void 0;
+exports.getPrimitiveFactoryFromValue = getPrimitiveFactoryFromValue;
+exports.isPrimitiveType = isPrimitiveType;
+const internal_ts_1 = require("../internal.js");
+// TODO: implement CoreType using types.custom ?
+/**
+ * @internal
+ * @hidden
+ */
+class CoreType extends internal_ts_1.SimpleType {
+    flags;
+    checker;
+    initializer;
+    constructor(name, flags, checker, initializer = internal_ts_1.identity) {
+        super(name);
+        this.flags = flags;
+        this.checker = checker;
+        this.initializer = initializer;
+        this.flags = flags;
+    }
+    describe() {
+        return this.name;
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        return (0, internal_ts_1.createScalarNode)(this, parent, subpath, environment, initialValue);
+    }
+    createNewInstance(snapshot) {
+        return this.initializer(snapshot);
+    }
+    isValidSnapshot(value, context) {
+        if ((0, internal_ts_1.isPrimitive)(value) && this.checker(value)) {
+            return (0, internal_ts_1.typeCheckSuccess)();
+        }
+        const typeName = this.name === "Date" ? "Date or a unix milliseconds timestamp" : this.name;
+        return (0, internal_ts_1.typeCheckFailure)(context, value, `Value is not a ${typeName}`);
+    }
+}
+exports.CoreType = CoreType;
+/**
+ * `types.string` - Creates a type that can only contain a string value.
+ * This type is used for string values by default
+ *
+ * Example:
+ * ```ts
+ * const Person = types.model({
+ *   firstName: types.string,
+ *   lastName: "Doe"
+ * })
+ * ```
+ */
+// tslint:disable-next-line:variable-name
+exports.string = new CoreType("string", internal_ts_1.TypeFlags.String, v => typeof v === "string");
+/**
+ * `types.number` - Creates a type that can only contain a numeric value.
+ * This type is used for numeric values by default
+ *
+ * Example:
+ * ```ts
+ * const Vector = types.model({
+ *   x: types.number,
+ *   y: 1.5
+ * })
+ * ```
+ */
+// tslint:disable-next-line:variable-name
+exports.number = new CoreType("number", internal_ts_1.TypeFlags.Number, v => typeof v === "number");
+/**
+ * `types.integer` - Creates a type that can only contain an integer value.
+ *
+ * Example:
+ * ```ts
+ * const Size = types.model({
+ *   width: types.integer,
+ *   height: 10
+ * })
+ * ```
+ */
+// tslint:disable-next-line:variable-name
+exports.integer = new CoreType("integer", internal_ts_1.TypeFlags.Integer, v => (0, internal_ts_1.isInteger)(v));
+/**
+ * `types.float` - Creates a type that can only contain an float value.
+ *
+ * Example:
+ * ```ts
+ * const Size = types.model({
+ *   width: types.float,
+ *   height: 10
+ * })
+ * ```
+ */
+// tslint:disable-next-line:variable-name
+exports.float = new CoreType("float", internal_ts_1.TypeFlags.Float, v => (0, internal_ts_1.isFloat)(v));
+/**
+ * `types.finite` - Creates a type that can only contain an finite value.
+ *
+ * Example:
+ * ```ts
+ * const Size = types.model({
+ *   width: types.finite,
+ *   height: 10
+ * })
+ * ```
+ */
+// tslint:disable-next-line:variable-name
+exports.finite = new CoreType("finite", internal_ts_1.TypeFlags.Finite, v => (0, internal_ts_1.isFinite)(v));
+/**
+ * `types.boolean` - Creates a type that can only contain a boolean value.
+ * This type is used for boolean values by default
+ *
+ * Example:
+ * ```ts
+ * const Thing = types.model({
+ *   isCool: types.boolean,
+ *   isAwesome: false
+ * })
+ * ```
+ */
+// tslint:disable-next-line:variable-name
+exports.boolean = new CoreType("boolean", internal_ts_1.TypeFlags.Boolean, v => typeof v === "boolean");
+/**
+ * `types.null` - The type of the value `null`
+ */
+exports.nullType = new CoreType("null", internal_ts_1.TypeFlags.Null, v => v === null);
+/**
+ * `types.undefined` - The type of the value `undefined`
+ */
+exports.undefinedType = new CoreType("undefined", internal_ts_1.TypeFlags.Undefined, v => v === undefined);
+const _DatePrimitive = new CoreType("Date", internal_ts_1.TypeFlags.Date, v => typeof v === "number" || v instanceof Date, v => (v instanceof Date ? v : new Date(v)));
+_DatePrimitive.getSnapshot = function (node) {
+    return node.storedValue.getTime();
+};
+/**
+ * `types.Date` - Creates a type that can only contain a javascript Date value.
+ *
+ * Example:
+ * ```ts
+ * const LogLine = types.model({
+ *   timestamp: types.Date,
+ * })
+ *
+ * LogLine.create({ timestamp: new Date() })
+ * ```
+ */
+exports.DatePrimitive = _DatePrimitive;
+/**
+ * @internal
+ * @hidden
+ */
+function getPrimitiveFactoryFromValue(value) {
+    switch (typeof value) {
+        case "string":
+            return exports.string;
+        case "number":
+            return exports.number; // In the future, isInteger(value) ? integer : number would be interesting, but would be too breaking for now
+        case "boolean":
+            return exports.boolean;
+        case "object":
+            if (value instanceof Date) {
+                return exports.DatePrimitive;
+            }
+    }
+    throw (0, internal_ts_1.fail)("Cannot determine primitive type from value " + value);
+}
+/**
+ * Returns if a given value represents a primitive type.
+ *
+ * @param type
+ * @returns
+ */
+function isPrimitiveType(type) {
+    return ((0, internal_ts_1.isType)(type) &&
+        (type.flags &
+            (internal_ts_1.TypeFlags.String |
+                internal_ts_1.TypeFlags.Number |
+                internal_ts_1.TypeFlags.Integer |
+                internal_ts_1.TypeFlags.Boolean |
+                internal_ts_1.TypeFlags.Date)) >
+            0);
+}
+//# sourceMappingURL=primitives.js.map

package/dist/types/primitives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.js","sourceRoot":"","sources":["../../src/types/primitives.ts"],"names":[],"mappings":"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"}

package/dist/types/utility-types/custom.d.ts

@@ -0,0 +1,74 @@
+import { type AnyObjectNode, type IType, type IValidationContext, type IValidationResult, SimpleType, TypeFlags } from "../../internal.ts";
+export interface CustomTypeOptions<S, T> {
+    /** Friendly name */
+    name: string;
+    /** given a serialized value and environment, how to turn it into the target type */
+    fromSnapshot(snapshot: S, env?: any): T;
+    /** return the serialization of the current value */
+    toSnapshot(value: T): S;
+    /** if true, this is a converted value, if false, it's a snapshot */
+    isTargetType(value: T | S): boolean;
+    /** a non empty string is assumed to be a validation error */
+    getValidationMessage(snapshot: S): string;
+}
+/**
+ * `types.custom` - Creates a custom type. Custom types can be used for arbitrary immutable values, that have a serializable representation. For example, to create your own Date representation, Decimal type etc.
+ *
+ * The signature of the options is:
+ * ```ts
+ * export interface CustomTypeOptions<S, T> {
+ *     // Friendly name
+ *     name: string
+ *     // given a serialized value and environment, how to turn it into the target type
+ *     fromSnapshot(snapshot: S, env: any): T
+ *     // return the serialization of the current value
+ *     toSnapshot(value: T): S
+ *     // if true, this is a converted value, if false, it's a snapshot
+ *     isTargetType(value: T | S): value is T
+ *     // a non empty string is assumed to be a validation error
+ *     getValidationMessage?(snapshot: S): string
+ * }
+ * ```
+ *
+ * Example:
+ * ```ts
+ * const DecimalPrimitive = types.custom<string, Decimal>({
+ *     name: "Decimal",
+ *     fromSnapshot(value: string) {
+ *         return new Decimal(value)
+ *     },
+ *     toSnapshot(value: Decimal) {
+ *         return value.toString()
+ *     },
+ *     isTargetType(value: string | Decimal): boolean {
+ *         return value instanceof Decimal
+ *     },
+ *     getValidationMessage(value: string): string {
+ *         if (/^-?\d+\.\d+$/.test(value)) return "" // OK
+ *         return `'${value}' doesn't look like a valid decimal number`
+ *     }
+ * })
+ *
+ * const Wallet = types.model({
+ *     balance: DecimalPrimitive
+ * })
+ * ```
+ *
+ * @param options
+ * @returns
+ */
+export declare function custom<S, T>(options: CustomTypeOptions<S, T>): IType<S | T, S, T>;
+/**
+ * @internal
+ * @hidden
+ */
+export declare class CustomType<S, T> extends SimpleType<S | T, S, T> {
+    protected readonly options: CustomTypeOptions<S, T>;
+    readonly flags = TypeFlags.Custom;
+    constructor(options: CustomTypeOptions<S, T>);
+    describe(): string;
+    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
+    getSnapshot(node: this["N"]): S;
+    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: S | T): this["N"];
+    reconcile(current: this["N"], value: S | T, parent: AnyObjectNode, subpath: string): this["N"];
+}

package/dist/types/utility-types/custom.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomType = void 0;
+exports.custom = custom;
+const internal_ts_1 = require("../../internal.js");
+/**
+ * `types.custom` - Creates a custom type. Custom types can be used for arbitrary immutable values, that have a serializable representation. For example, to create your own Date representation, Decimal type etc.
+ *
+ * The signature of the options is:
+ * ```ts
+ * export interface CustomTypeOptions<S, T> {
+ *     // Friendly name
+ *     name: string
+ *     // given a serialized value and environment, how to turn it into the target type
+ *     fromSnapshot(snapshot: S, env: any): T
+ *     // return the serialization of the current value
+ *     toSnapshot(value: T): S
+ *     // if true, this is a converted value, if false, it's a snapshot
+ *     isTargetType(value: T | S): value is T
+ *     // a non empty string is assumed to be a validation error
+ *     getValidationMessage?(snapshot: S): string
+ * }
+ * ```
+ *
+ * Example:
+ * ```ts
+ * const DecimalPrimitive = types.custom<string, Decimal>({
+ *     name: "Decimal",
+ *     fromSnapshot(value: string) {
+ *         return new Decimal(value)
+ *     },
+ *     toSnapshot(value: Decimal) {
+ *         return value.toString()
+ *     },
+ *     isTargetType(value: string | Decimal): boolean {
+ *         return value instanceof Decimal
+ *     },
+ *     getValidationMessage(value: string): string {
+ *         if (/^-?\d+\.\d+$/.test(value)) return "" // OK
+ *         return `'${value}' doesn't look like a valid decimal number`
+ *     }
+ * })
+ *
+ * const Wallet = types.model({
+ *     balance: DecimalPrimitive
+ * })
+ * ```
+ *
+ * @param options
+ * @returns
+ */
+function custom(options) {
+    return new CustomType(options);
+}
+/**
+ * @internal
+ * @hidden
+ */
+class CustomType extends internal_ts_1.SimpleType {
+    options;
+    flags = internal_ts_1.TypeFlags.Custom;
+    constructor(options) {
+        super(options.name);
+        this.options = options;
+    }
+    describe() {
+        return this.name;
+    }
+    isValidSnapshot(value, context) {
+        if (this.options.isTargetType(value)) {
+            return (0, internal_ts_1.typeCheckSuccess)();
+        }
+        const typeError = this.options.getValidationMessage(value);
+        if (typeError) {
+            return (0, internal_ts_1.typeCheckFailure)(context, value, `Invalid value for type '${this.name}': ${typeError}`);
+        }
+        return (0, internal_ts_1.typeCheckSuccess)();
+    }
+    getSnapshot(node) {
+        return this.options.toSnapshot(node.storedValue);
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        const valueToStore = this.options.isTargetType(initialValue)
+            ? initialValue
+            : this.options.fromSnapshot(initialValue, parent && parent.root.environment);
+        return (0, internal_ts_1.createScalarNode)(this, parent, subpath, environment, valueToStore);
+    }
+    reconcile(current, value, parent, subpath) {
+        const isSnapshot = !this.options.isTargetType(value);
+        // in theory customs use scalar nodes which cannot be detached, but still...
+        if (!current.isDetaching) {
+            const unchanged = current.type === this &&
+                (isSnapshot
+                    ? value === current.snapshot
+                    : value === current.storedValue);
+            if (unchanged) {
+                current.setParent(parent, subpath);
+                return current;
+            }
+        }
+        const valueToStore = isSnapshot
+            ? this.options.fromSnapshot(value, parent.root.environment)
+            : value;
+        const newNode = this.instantiate(parent, subpath, undefined, valueToStore);
+        current.die(); // noop if detaching
+        return newNode;
+    }
+}
+exports.CustomType = CustomType;
+//# sourceMappingURL=custom.js.map

package/dist/types/utility-types/custom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.js","sourceRoot":"","sources":["../../../src/types/utility-types/custom.ts"],"names":[],"mappings":";;;AAyEA,wBAIC;AA7ED,mDAU0B;AAiB1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,SAAgB,MAAM,CACpB,OAAgC;IAEhC,OAAO,IAAI,UAAU,CAAO,OAAO,CAAC,CAAA;AACtC,CAAC;AAED;;;GAGG;AACH,MAAa,UAAiB,SAAQ,wBAAuB;IAG5B;IAFtB,KAAK,GAAG,uBAAS,CAAC,MAAM,CAAA;IAEjC,YAA+B,OAAgC;QAC7D,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QADU,YAAO,GAAP,OAAO,CAAyB;IAE/D,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAED,eAAe,CACb,KAAgB,EAChB,OAA2B;QAE3B,IAAI,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YACrC,OAAO,IAAA,8BAAgB,GAAE,CAAA;QAC3B,CAAC;QAED,MAAM,SAAS,GAAW,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,KAAU,CAAC,CAAA;QACvE,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,IAAA,8BAAgB,EACrB,OAAO,EACP,KAAK,EACL,2BAA2B,IAAI,CAAC,IAAI,MAAM,SAAS,EAAE,CACtD,CAAA;QACH,CAAC;QACD,OAAO,IAAA,8BAAgB,GAAE,CAAA;IAC3B,CAAC;IAED,WAAW,CAAC,IAAe;QACzB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;IAClD,CAAC;IAED,WAAW,CACT,MAA4B,EAC5B,OAAe,EACf,WAAgB,EAChB,YAAmB;QAEnB,MAAM,YAAY,GAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC;YAC7D,CAAC,CAAE,YAAkB;YACrB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CACvB,YAAiB,EACjB,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAClC,CAAA;QACL,OAAO,IAAA,8BAAgB,EAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,CAAC,CAAA;IAC3E,CAAC;IAED,SAAS,CACP,OAAkB,EAClB,KAAY,EACZ,MAAqB,EACrB,OAAe;QAEf,MAAM,UAAU,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;QACpD,4EAA4E;QAC5E,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YACzB,MAAM,SAAS,GACb,OAAO,CAAC,IAAI,KAAK,IAAI;gBACrB,CAAC,UAAU;oBACT,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC,QAAQ;oBAC5B,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC,WAAW,CAAC,CAAA;YACpC,IAAI,SAAS,EAAE,CAAC;gBACd,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;gBAClC,OAAO,OAAO,CAAA;YAChB,CAAC;QACH,CAAC;QACD,MAAM,YAAY,GAAM,UAAU;YAChC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAU,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC;YAChE,CAAC,CAAE,KAAW,CAAA;QAChB,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,CAAC,CAAA;QAC1E,OAAO,CAAC,GAAG,EAAE,CAAA,CAAC,oBAAoB;QAClC,OAAO,OAAO,CAAA;IAChB,CAAC;CACF;AA3ED,gCA2EC"}

package/dist/types/utility-types/enumeration.d.ts

@@ -0,0 +1,5 @@
+import { type ISimpleType } from "../../internal.ts";
+/** @hidden */
+export type UnionStringArray<T extends readonly string[]> = T[number];
+export declare function enumeration<T extends readonly string[]>(options: T): ISimpleType<UnionStringArray<T>>;
+export declare function enumeration<T extends string>(name: string, options: T[]): ISimpleType<UnionStringArray<T[]>>;

package/dist/types/utility-types/enumeration.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumeration = enumeration;
+const internal_ts_1 = require("../../internal.js");
+/**
+ * `types.enumeration` - Can be used to create an string based enumeration.
+ * (note: this methods is just sugar for a union of string literals)
+ *
+ * Example:
+ * ```ts
+ * const TrafficLight = types.model({
+ *   color: types.enumeration("Color", ["Red", "Orange", "Green"])
+ * })
+ * ```
+ *
+ * @param name descriptive name of the enumeration (optional)
+ * @param options possible values this enumeration can have
+ * @returns
+ */
+function enumeration(name, options) {
+    const realOptions = typeof name === "string" ? options : name;
+    // check all options
+    if ((0, internal_ts_1.devMode)()) {
+        realOptions.forEach((option, i) => {
+            (0, internal_ts_1.assertIsString)(option, i + 1);
+        });
+    }
+    const type = (0, internal_ts_1.union)(...realOptions.map(option => (0, internal_ts_1.literal)("" + option)));
+    if (typeof name === "string") {
+        type.name = name;
+    }
+    return type;
+}
+//# sourceMappingURL=enumeration.js.map

package/dist/types/utility-types/enumeration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumeration.js","sourceRoot":"","sources":["../../../src/types/utility-types/enumeration.ts"],"names":[],"mappings":";;AAuCA,kCAgBC;AAvDD,mDAM0B;AAkB1B;;;;;;;;;;;;;;GAcG;AACH,SAAgB,WAAW,CACzB,IAAuB,EACvB,OAAa;IAEb,MAAM,WAAW,GAAa,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAQ,CAAC,CAAC,CAAC,IAAI,CAAA;IACxE,oBAAoB;IACpB,IAAI,IAAA,qBAAO,GAAE,EAAE,CAAC;QACd,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAChC,IAAA,4BAAc,EAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;QAC/B,CAAC,CAAC,CAAA;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,IAAA,mBAAK,EAAC,GAAG,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAA,qBAAO,EAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;IACtE,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/types/utility-types/frozen.d.ts

@@ -0,0 +1,23 @@
+import { type AnyObjectNode, type IAnyType, type IType, type IValidationContext, type IValidationResult, SimpleType, TypeFlags } from "../../internal.ts";
+/**
+ * @internal
+ * @hidden
+ */
+export declare class Frozen<T> extends SimpleType<T, T, T> {
+    private subType?;
+    flags: TypeFlags;
+    constructor(subType?: IAnyType | undefined);
+    describe(): string;
+    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, value: this["C"]): this["N"];
+    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
+}
+export declare function frozen<C>(subType: IType<C, any, any>): IType<C, C, C>;
+export declare function frozen<T>(defaultValue: T): IType<T | undefined | null, T, T>;
+export declare function frozen<T = any>(): IType<T, T, T>;
+/**
+ * Returns if a given value represents a frozen type.
+ *
+ * @param type
+ * @returns
+ */
+export declare function isFrozenType<IT extends IType<T | any, T, T>, T = any>(type: IT): type is IT;

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Frozen = void 0;
+exports.frozen = frozen;
+exports.isFrozenType = isFrozenType;
+const internal_ts_1 = require("../../internal.js");
+/**
+ * @internal
+ * @hidden
+ */
+class Frozen extends internal_ts_1.SimpleType {
+    subType;
+    flags = internal_ts_1.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 (0, internal_ts_1.createScalarNode)(this, parent, subpath, environment, (0, internal_ts_1.deepFreeze)(value));
+    }
+    isValidSnapshot(value, context) {
+        if (!(0, internal_ts_1.isSerializable)(value)) {
+            return (0, internal_ts_1.typeCheckFailure)(context, value, "Value is not serializable and cannot be frozen");
+        }
+        if (this.subType) {
+            return this.subType.validate(value, context);
+        }
+        return (0, internal_ts_1.typeCheckSuccess)();
+    }
+}
+exports.Frozen = Frozen;
+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
+ */
+function frozen(arg) {
+    if (arguments.length === 0) {
+        return untypedFrozenInstance;
+    }
+    else if ((0, internal_ts_1.isType)(arg)) {
+        return new Frozen(arg);
+    }
+    else {
+        return (0, internal_ts_1.optional)(untypedFrozenInstance, arg);
+    }
+}
+/**
+ * Returns if a given value represents a frozen type.
+ *
+ * @param type
+ * @returns
+ */
+function isFrozenType(type) {
+    return (0, internal_ts_1.isType)(type) && (type.flags & internal_ts_1.TypeFlags.Frozen) > 0;
+}
+//# sourceMappingURL=frozen.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frozen.js","sourceRoot":"","sources":["../../../src/types/utility-types/frozen.ts"],"names":[],"mappings":";;;AA+GA,wBAQC;AAQD,oCAIC;AAnID,mDAe0B;AAE1B;;;GAGG;AACH,MAAa,MAAU,SAAQ,wBAAmB;IAG5B;IAFpB,KAAK,GAAG,uBAAS,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,IAAA,8BAAgB,EACrB,IAAI,EACJ,MAAM,EACN,OAAO,EACP,WAAW,EACX,IAAA,wBAAU,EAAC,KAAK,CAAC,CAClB,CAAA;IACH,CAAC;IAED,eAAe,CACb,KAAgB,EAChB,OAA2B;QAE3B,IAAI,CAAC,IAAA,4BAAc,EAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,IAAA,8BAAgB,EACrB,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,IAAA,8BAAgB,GAAE,CAAA;IAC3B,CAAC;CACF;AA3CD,wBA2CC;AAED,MAAM,qBAAqB,GAAG,IAAI,MAAM,EAAE,CAAA;AAK1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,SAAgB,MAAM,CAAC,GAAS;IAC9B,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,qBAAqB,CAAA;IAC9B,CAAC;SAAM,IAAI,IAAA,oBAAM,EAAC,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,CAAA;IACxB,CAAC;SAAM,CAAC;QACN,OAAO,IAAA,sBAAQ,EAAC,qBAAqB,EAAE,GAAG,CAAC,CAAA;IAC7C,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAgB,YAAY,CAC1B,IAAQ;IAER,OAAO,IAAA,oBAAM,EAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,uBAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;AAC5D,CAAC"}