@jbrowse/mobx-state-tree 5.7.1 → 5.8.7

package/dist/types/index.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.types = void 0;
-// we import the types to re-export them inside types.
-const internal_ts_1 = require("../internal.js");
-exports.types = {
-    enumeration: internal_ts_1.enumeration,
-    model: internal_ts_1.model,
-    compose: internal_ts_1.compose,
-    custom: internal_ts_1.custom,
-    reference: internal_ts_1.reference,
-    safeReference: internal_ts_1.safeReference,
-    union: internal_ts_1.union,
-    optional: internal_ts_1.optional,
-    literal: internal_ts_1.literal,
-    maybe: internal_ts_1.maybe,
-    maybeNull: internal_ts_1.maybeNull,
-    refinement: internal_ts_1.refinement,
-    string: internal_ts_1.string,
-    boolean: internal_ts_1.boolean,
-    number: internal_ts_1.number,
-    integer: internal_ts_1.integer,
-    float: internal_ts_1.float,
-    finite: internal_ts_1.finite,
-    Date: internal_ts_1.DatePrimitive,
-    map: internal_ts_1.map,
-    array: internal_ts_1.array,
-    frozen: internal_ts_1.frozen,
-    identifier: internal_ts_1.identifier,
-    identifierNumber: internal_ts_1.identifierNumber,
-    late: internal_ts_1.late,
-    lazy: internal_ts_1.lazy,
-    undefined: internal_ts_1.undefinedType,
-    null: internal_ts_1.nullType,
-    snapshotProcessor: internal_ts_1.snapshotProcessor,
-    resilient: internal_ts_1.resilient
-};
-//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;AAAA,sDAAsD;AACtD,gDA+BuB;AAEV,QAAA,KAAK,GAAG;IACnB,WAAW,EAAX,yBAAW;IACX,KAAK,EAAL,mBAAK;IACL,OAAO,EAAP,qBAAO;IACP,MAAM,EAAN,oBAAM;IACN,SAAS,EAAT,uBAAS;IACT,aAAa,EAAb,2BAAa;IACb,KAAK,EAAL,mBAAK;IACL,QAAQ,EAAR,sBAAQ;IACR,OAAO,EAAP,qBAAO;IACP,KAAK,EAAL,mBAAK;IACL,SAAS,EAAT,uBAAS;IACT,UAAU,EAAV,wBAAU;IACV,MAAM,EAAN,oBAAM;IACN,OAAO,EAAP,qBAAO;IACP,MAAM,EAAN,oBAAM;IACN,OAAO,EAAP,qBAAO;IACP,KAAK,EAAL,mBAAK;IACL,MAAM,EAAN,oBAAM;IACN,IAAI,EAAE,2BAAa;IACnB,GAAG,EAAH,iBAAG;IACH,KAAK,EAAL,mBAAK;IACL,MAAM,EAAN,oBAAM;IACN,UAAU,EAAV,wBAAU;IACV,gBAAgB,EAAhB,8BAAgB;IAChB,IAAI,EAAJ,kBAAI;IACJ,IAAI,EAAJ,kBAAI;IACJ,SAAS,EAAE,2BAAa;IACxB,IAAI,EAAE,sBAAQ;IACd,iBAAiB,EAAjB,+BAAiB;IACjB,SAAS,EAAT,uBAAS;CACV,CAAA","sourcesContent":["// we import the types to re-export them inside types.\nimport {\n  DatePrimitive,\n  array,\n  boolean,\n  compose,\n  custom,\n  enumeration,\n  finite,\n  float,\n  frozen,\n  identifier,\n  identifierNumber,\n  integer,\n  late,\n  lazy,\n  literal,\n  map,\n  maybe,\n  maybeNull,\n  model,\n  nullType,\n  number,\n  optional,\n  reference,\n  refinement,\n  safeReference,\n  resilient,\n  snapshotProcessor,\n  string,\n  undefinedType,\n  union\n} from \"../internal.ts\"\n\nexport const types = {\n  enumeration,\n  model,\n  compose,\n  custom,\n  reference,\n  safeReference,\n  union,\n  optional,\n  literal,\n  maybe,\n  maybeNull,\n  refinement,\n  string,\n  boolean,\n  number,\n  integer,\n  float,\n  finite,\n  Date: DatePrimitive,\n  map,\n  array,\n  frozen,\n  identifier,\n  identifierNumber,\n  late,\n  lazy,\n  undefined: undefinedType,\n  null: nullType,\n  snapshotProcessor,\n  resilient\n}\n"]}

package/dist/types/primitives.d.ts

@@ -1,125 +0,0 @@
-import { SimpleType } from "../core/type/type.ts";
-import { 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

@@ -1,183 +0,0 @@
-"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 type_ts_1 = require("../core/type/type.js");
-const internal_ts_1 = require("../internal.js");
-// TODO: implement CoreType using types.custom ?
-/**
- * @internal
- * @hidden
- */
-class CoreType extends type_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

@@ -1 +0,0 @@
-{"version":3,"file":"primitives.js","sourceRoot":"","sources":["../../src/types/primitives.ts"],"names":[],"mappings":"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","sourcesContent":["import { SimpleType } from \"../core/type/type.ts\"\nimport {\n  TypeFlags,\n  createScalarNode,\n  fail,\n  identity,\n  isFinite,\n  isFloat,\n  isInteger,\n  isPrimitive,\n  isType,\n  typeCheckFailure,\n  typeCheckSuccess\n} from \"../internal.ts\"\n\nimport type {\n  AnyNode,\n  AnyObjectNode,\n  ISimpleType,\n  IType,\n  IValidationContext,\n  IValidationResult\n} from \"../internal.ts\"\n\n// TODO: implement CoreType using types.custom ?\n/**\n * @internal\n * @hidden\n */\nexport class CoreType<C, S, T> extends SimpleType<C, S, T> {\n  constructor(\n    name: string,\n    readonly flags: TypeFlags,\n    private readonly checker: (value: C) => boolean,\n    private readonly initializer: (v: C) => T = identity\n  ) {\n    super(name)\n    this.flags = flags\n  }\n\n  describe() {\n    return this.name\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: C\n  ): this[\"N\"] {\n    return createScalarNode(this, parent, subpath, environment, initialValue)\n  }\n\n  createNewInstance(snapshot: C) {\n    return this.initializer(snapshot)\n  }\n\n  isValidSnapshot(value: C, context: IValidationContext): IValidationResult {\n    if (isPrimitive(value) && this.checker(value as any)) {\n      return typeCheckSuccess()\n    }\n    const typeName =\n      this.name === \"Date\" ? \"Date or a unix milliseconds timestamp\" : this.name\n    return typeCheckFailure(context, value, `Value is not a ${typeName}`)\n  }\n}\n\n/**\n * `types.string` - Creates a type that can only contain a string value.\n * This type is used for string values by default\n *\n * Example:\n * ```ts\n * const Person = types.model({\n *   firstName: types.string,\n *   lastName: \"Doe\"\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const string: ISimpleType<string> = new CoreType<string, string, string>(\n  \"string\",\n  TypeFlags.String,\n  v => typeof v === \"string\"\n)\n\n/**\n * `types.number` - Creates a type that can only contain a numeric value.\n * This type is used for numeric values by default\n *\n * Example:\n * ```ts\n * const Vector = types.model({\n *   x: types.number,\n *   y: 1.5\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const number: ISimpleType<number> = new CoreType<number, number, number>(\n  \"number\",\n  TypeFlags.Number,\n  v => typeof v === \"number\"\n)\n\n/**\n * `types.integer` - Creates a type that can only contain an integer value.\n *\n * Example:\n * ```ts\n * const Size = types.model({\n *   width: types.integer,\n *   height: 10\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const integer: ISimpleType<number> = new CoreType<\n  number,\n  number,\n  number\n>(\"integer\", TypeFlags.Integer, v => isInteger(v))\n\n/**\n * `types.float` - Creates a type that can only contain an float value.\n *\n * Example:\n * ```ts\n * const Size = types.model({\n *   width: types.float,\n *   height: 10\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const float: ISimpleType<number> = new CoreType<number, number, number>(\n  \"float\",\n  TypeFlags.Float,\n  v => isFloat(v)\n)\n\n/**\n * `types.finite` - Creates a type that can only contain an finite value.\n *\n * Example:\n * ```ts\n * const Size = types.model({\n *   width: types.finite,\n *   height: 10\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const finite: ISimpleType<number> = new CoreType<number, number, number>(\n  \"finite\",\n  TypeFlags.Finite,\n  v => isFinite(v)\n)\n\n/**\n * `types.boolean` - Creates a type that can only contain a boolean value.\n * This type is used for boolean values by default\n *\n * Example:\n * ```ts\n * const Thing = types.model({\n *   isCool: types.boolean,\n *   isAwesome: false\n * })\n * ```\n */\n// tslint:disable-next-line:variable-name\nexport const boolean: ISimpleType<boolean> = new CoreType<\n  boolean,\n  boolean,\n  boolean\n>(\"boolean\", TypeFlags.Boolean, v => typeof v === \"boolean\")\n\n/**\n * `types.null` - The type of the value `null`\n */\nexport const nullType: ISimpleType<null> = new CoreType<null, null, null>(\n  \"null\",\n  TypeFlags.Null,\n  v => v === null\n)\n\n/**\n * `types.undefined` - The type of the value `undefined`\n */\nexport const undefinedType: ISimpleType<undefined> = new CoreType<\n  undefined,\n  undefined,\n  undefined\n>(\"undefined\", TypeFlags.Undefined, v => v === undefined)\n\nconst _DatePrimitive = new CoreType<number | Date, number, Date>(\n  \"Date\",\n  TypeFlags.Date,\n  v => typeof v === \"number\" || v instanceof Date,\n  v => (v instanceof Date ? v : new Date(v))\n)\n_DatePrimitive.getSnapshot = function (node: AnyNode) {\n  return node.storedValue.getTime()\n}\n\n/**\n * `types.Date` - Creates a type that can only contain a javascript Date value.\n *\n * Example:\n * ```ts\n * const LogLine = types.model({\n *   timestamp: types.Date,\n * })\n *\n * LogLine.create({ timestamp: new Date() })\n * ```\n */\nexport const DatePrimitive: IType<number | Date, number, Date> = _DatePrimitive\n\n/**\n * @internal\n * @hidden\n */\nexport function getPrimitiveFactoryFromValue(value: any): ISimpleType<any> {\n  switch (typeof value) {\n    case \"string\":\n      return string\n    case \"number\":\n      return number // In the future, isInteger(value) ? integer : number would be interesting, but would be too breaking for now\n    case \"boolean\":\n      return boolean\n    case \"object\":\n      if (value instanceof Date) {\n        return DatePrimitive\n      }\n  }\n  throw fail(\"Cannot determine primitive type from value \" + value)\n}\n\n/**\n * Returns if a given value represents a primitive type.\n *\n * @param type\n * @returns\n */\nexport function isPrimitiveType<\n  IT extends\n    | ISimpleType<string>\n    | ISimpleType<number>\n    | ISimpleType<boolean>\n    | typeof DatePrimitive\n>(type: IT): type is IT {\n  return (\n    isType(type) &&\n    (type.flags &\n      (TypeFlags.String |\n        TypeFlags.Number |\n        TypeFlags.Integer |\n        TypeFlags.Boolean |\n        TypeFlags.Date)) >\n      0\n  )\n}\n"]}

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

@@ -1,75 +0,0 @@
-import { SimpleType } from "../../core/type/type.ts";
-import { type AnyObjectNode, type IType, type IValidationContext, type IValidationResult, 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

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomType = void 0;
-exports.custom = custom;
-const type_ts_1 = require("../../core/type/type.js");
-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 type_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

@@ -1 +0,0 @@
-{"version":3,"file":"custom.js","sourceRoot":"","sources":["../../../src/types/utility-types/custom.ts"],"names":[],"mappings":";;;AAyEA,wBAIC;AA7ED,qDAAoD;AACpD,mDAS0B;AAiB1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,SAAgB,MAAM,CACpB,OAAgC;IAEhC,OAAO,IAAI,UAAU,CAAO,OAAO,CAAC,CAAA;AACtC,CAAC;AAED;;;GAGG;AACH,MAAa,UAAiB,SAAQ,oBAAuB;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","sourcesContent":["import { SimpleType } from \"../../core/type/type.ts\"\nimport {\n  type AnyObjectNode,\n  type IType,\n  type IValidationContext,\n  type IValidationResult,\n  TypeFlags,\n  createScalarNode,\n  typeCheckFailure,\n  typeCheckSuccess\n} from \"../../internal.ts\"\n\nexport interface CustomTypeOptions<S, T> {\n  /** Friendly name */\n  name: string\n  /** given a serialized value and environment, how to turn it into the target type */\n  fromSnapshot(snapshot: S, env?: any): T\n  /** return the serialization of the current value */\n  toSnapshot(value: T): S\n  /** if true, this is a converted value, if false, it's a snapshot */\n  isTargetType(value: T | S): boolean\n  /** a non empty string is assumed to be a validation error */\n  getValidationMessage(snapshot: S): string\n  // TODO: isSnapshotEqual\n  // TODO: isValueEqual\n}\n\n/**\n * `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.\n *\n * The signature of the options is:\n * ```ts\n * export interface CustomTypeOptions<S, T> {\n *     // Friendly name\n *     name: string\n *     // given a serialized value and environment, how to turn it into the target type\n *     fromSnapshot(snapshot: S, env: any): T\n *     // return the serialization of the current value\n *     toSnapshot(value: T): S\n *     // if true, this is a converted value, if false, it's a snapshot\n *     isTargetType(value: T | S): value is T\n *     // a non empty string is assumed to be a validation error\n *     getValidationMessage?(snapshot: S): string\n * }\n * ```\n *\n * Example:\n * ```ts\n * const DecimalPrimitive = types.custom<string, Decimal>({\n *     name: \"Decimal\",\n *     fromSnapshot(value: string) {\n *         return new Decimal(value)\n *     },\n *     toSnapshot(value: Decimal) {\n *         return value.toString()\n *     },\n *     isTargetType(value: string | Decimal): boolean {\n *         return value instanceof Decimal\n *     },\n *     getValidationMessage(value: string): string {\n *         if (/^-?\\d+\\.\\d+$/.test(value)) return \"\" // OK\n *         return `'${value}' doesn't look like a valid decimal number`\n *     }\n * })\n *\n * const Wallet = types.model({\n *     balance: DecimalPrimitive\n * })\n * ```\n *\n * @param options\n * @returns\n */\nexport function custom<S, T>(\n  options: CustomTypeOptions<S, T>\n): IType<S | T, S, T> {\n  return new CustomType<S, T>(options)\n}\n\n/**\n * @internal\n * @hidden\n */\nexport class CustomType<S, T> extends SimpleType<S | T, S, T> {\n  readonly flags = TypeFlags.Custom\n\n  constructor(protected readonly options: CustomTypeOptions<S, T>) {\n    super(options.name)\n  }\n\n  describe() {\n    return this.name\n  }\n\n  isValidSnapshot(\n    value: this[\"C\"],\n    context: IValidationContext\n  ): IValidationResult {\n    if (this.options.isTargetType(value)) {\n      return typeCheckSuccess()\n    }\n\n    const typeError: string = this.options.getValidationMessage(value as S)\n    if (typeError) {\n      return typeCheckFailure(\n        context,\n        value,\n        `Invalid value for type '${this.name}': ${typeError}`\n      )\n    }\n    return typeCheckSuccess()\n  }\n\n  getSnapshot(node: this[\"N\"]): S {\n    return this.options.toSnapshot(node.storedValue)\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: S | T\n  ): this[\"N\"] {\n    const valueToStore: T = this.options.isTargetType(initialValue)\n      ? (initialValue as T)\n      : this.options.fromSnapshot(\n          initialValue as S,\n          parent && parent.root.environment\n        )\n    return createScalarNode(this, parent, subpath, environment, valueToStore)\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    value: S | T,\n    parent: AnyObjectNode,\n    subpath: string\n  ): this[\"N\"] {\n    const isSnapshot = !this.options.isTargetType(value)\n    // in theory customs use scalar nodes which cannot be detached, but still...\n    if (!current.isDetaching) {\n      const unchanged =\n        current.type === this &&\n        (isSnapshot\n          ? value === current.snapshot\n          : value === current.storedValue)\n      if (unchanged) {\n        current.setParent(parent, subpath)\n        return current\n      }\n    }\n    const valueToStore: T = isSnapshot\n      ? this.options.fromSnapshot(value as S, parent.root.environment)\n      : (value as T)\n    const newNode = this.instantiate(parent, subpath, undefined, valueToStore)\n    current.die() // noop if detaching\n    return newNode\n  }\n}\n"]}

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

@@ -1,5 +0,0 @@
-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

@@ -1,34 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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","sourcesContent":["import {\n  type ISimpleType,\n  assertIsString,\n  devMode,\n  literal,\n  union\n} from \"../../internal.ts\"\n\n/** @hidden */\nexport type UnionStringArray<T extends readonly string[]> = T[number]\n\n// strongly typed enumeration forms for plain and readonly string arrays (when passed directly to the function).\n// with these overloads, we get correct typing for native TS string enums when we use Object.values(Enum) as Enum[] as options.\n// these overloads also allow both mutable and immutable arrays, making types.enumeration<Enum>(Object.values(Enum)) possible.\n// the only case where this doesn't work is when passing to the function an array variable with a mutable type constraint;\n// for these cases, it will just fallback and assume the type is a generic string.\nexport function enumeration<T extends readonly string[]>(\n  options: T\n): ISimpleType<UnionStringArray<T>>\nexport function enumeration<T extends string>(\n  name: string,\n  options: T[]\n): ISimpleType<UnionStringArray<T[]>>\n\n/**\n * `types.enumeration` - Can be used to create an string based enumeration.\n * (note: this methods is just sugar for a union of string literals)\n *\n * Example:\n * ```ts\n * const TrafficLight = types.model({\n *   color: types.enumeration(\"Color\", [\"Red\", \"Orange\", \"Green\"])\n * })\n * ```\n *\n * @param name descriptive name of the enumeration (optional)\n * @param options possible values this enumeration can have\n * @returns\n */\nexport function enumeration(\n  name: string | string[],\n  options?: any\n): ISimpleType<string> {\n  const realOptions: string[] = typeof name === \"string\" ? options! : name\n  // check all options\n  if (devMode()) {\n    realOptions.forEach((option, i) => {\n      assertIsString(option, i + 1)\n    })\n  }\n  const type = union(...realOptions.map(option => literal(\"\" + option)))\n  if (typeof name === \"string\") {\n    type.name = name\n  }\n  return type\n}\n"]}

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

@@ -1,24 +0,0 @@
-import { SimpleType } from "../../core/type/type.ts";
-import { type AnyObjectNode, type IAnyType, type IType, type IValidationContext, type IValidationResult, 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;