@jbrowse/mobx-state-tree 5.6.3 → 5.6.9

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

@@ -0,0 +1,86 @@
+import { type AnyObjectNode, type ISimpleType, type IValidationContext, type IValidationResult, type ScalarNode, SimpleType, 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/dist/types/utility-types/identifier.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identifierNumber = exports.identifier = exports.IdentifierNumberType = exports.IdentifierType = void 0;
+exports.isIdentifierType = isIdentifierType;
+exports.normalizeIdentifier = normalizeIdentifier;
+exports.isValidIdentifier = isValidIdentifier;
+exports.assertIsValidIdentifier = assertIsValidIdentifier;
+const internal_ts_1 = require("../../internal.js");
+class BaseIdentifierType extends internal_ts_1.SimpleType {
+    validType;
+    flags = internal_ts_1.TypeFlags.Identifier;
+    constructor(name, validType) {
+        super(name);
+        this.validType = validType;
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        if (!parent || !(parent.type instanceof internal_ts_1.ModelType)) {
+            throw (0, internal_ts_1.fail)(`Identifier types can only be instantiated as direct child of a model type`);
+        }
+        return (0, internal_ts_1.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 (0, internal_ts_1.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 (0, internal_ts_1.typeCheckFailure)(context, value, `Value is not a valid ${this.describe()}, expected a ${this.validType}`);
+        }
+        return (0, internal_ts_1.typeCheckSuccess)();
+    }
+}
+/**
+ * @internal
+ * @hidden
+ */
+class IdentifierType extends BaseIdentifierType {
+    flags = internal_ts_1.TypeFlags.Identifier;
+    constructor() {
+        super(`identifier`, "string");
+    }
+    describe() {
+        return `identifier`;
+    }
+}
+exports.IdentifierType = IdentifierType;
+/**
+ * @internal
+ * @hidden
+ */
+class IdentifierNumberType extends BaseIdentifierType {
+    constructor() {
+        super("identifierNumber", "number");
+    }
+    getSnapshot(node) {
+        return node.storedValue;
+    }
+    describe() {
+        return `identifierNumber`;
+    }
+}
+exports.IdentifierNumberType = IdentifierNumberType;
+/**
+ * `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
+ */
+exports.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
+ */
+exports.identifierNumber = new IdentifierNumberType();
+/**
+ * Returns if a given value represents an identifier type.
+ *
+ * @param type
+ * @returns
+ */
+function isIdentifierType(type) {
+    return (0, internal_ts_1.isType)(type) && (type.flags & internal_ts_1.TypeFlags.Identifier) > 0;
+}
+/**
+ * @internal
+ * @hidden
+ */
+function normalizeIdentifier(id) {
+    return "" + id;
+}
+/**
+ * @internal
+ * @hidden
+ */
+function isValidIdentifier(id) {
+    return typeof id === "string" || typeof id === "number";
+}
+/**
+ * @internal
+ * @hidden
+ */
+function assertIsValidIdentifier(id, argNumber) {
+    (0, internal_ts_1.assertArg)(id, isValidIdentifier, "string or number (identifier)", argNumber);
+}
+//# sourceMappingURL=identifier.js.map

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

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

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

@@ -0,0 +1,10 @@
+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/dist/types/utility-types/late.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.late = late;
+exports.isLateType = isLateType;
+const internal_ts_1 = require("../../internal.js");
+class Late extends internal_ts_1.BaseType {
+    _definition;
+    _subType;
+    get flags() {
+        return (this._subType ? this._subType.flags : 0) | internal_ts_1.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 (0, internal_ts_1.fail)("Late type seems to be used too early, the definition (still) returns undefined");
+            }
+            if (t) {
+                if ((0, internal_ts_1.devMode)() && !(0, internal_ts_1.isType)(t)) {
+                    throw (0, internal_ts_1.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 (0, internal_ts_1.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 : internal_ts_1.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
+ */
+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 ((0, internal_ts_1.devMode)()) {
+        if (!(typeof type === "function" && type.length === 0)) {
+            throw (0, internal_ts_1.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
+ */
+function isLateType(type) {
+    return (0, internal_ts_1.isType)(type) && (type.flags & internal_ts_1.TypeFlags.Late) > 0;
+}
+//# sourceMappingURL=late.js.map

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

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

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

@@ -0,0 +1,22 @@
+import { type AnyObjectNode, type IType, type IValidationContext, type IValidationResult, SimpleType, 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/dist/types/utility-types/lazy.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lazy = void 0;
+exports.lazy = lazy;
+const mobx_1 = require("mobx");
+const internal_ts_1 = require("../../internal.js");
+function lazy(name, options) {
+    // TODO: fix this unknown casting to be stricter
+    return new Lazy(name, options);
+}
+/**
+ * @internal
+ * @hidden
+ */
+class Lazy extends internal_ts_1.SimpleType {
+    options;
+    flags = internal_ts_1.TypeFlags.Lazy;
+    loadedType = null;
+    pendingNodeList = mobx_1.observable.array();
+    constructor(name, options) {
+        super(name);
+        this.options = options;
+        (0, mobx_1.when)(() => this.pendingNodeList.length > 0 &&
+            this.pendingNodeList.some(node => node.isAlive &&
+                this.options.shouldLoadPredicate(node.parent ? node.parent.value : null)), () => {
+            this.options.loadType().then((0, mobx_1.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 = (0, internal_ts_1.createScalarNode)(this, parent, subpath, environment, (0, internal_ts_1.deepFreeze)(value));
+        this.pendingNodeList.push(node);
+        (0, mobx_1.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 (!(0, internal_ts_1.isSerializable)(value)) {
+            return (0, internal_ts_1.typeCheckFailure)(context, value, "Value is not serializable and cannot be lazy");
+        }
+        return (0, internal_ts_1.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);
+    }
+}
+exports.Lazy = Lazy;
+//# sourceMappingURL=lazy.js.map

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

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

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

@@ -0,0 +1,37 @@
+import { type AnyObjectNode, type ISimpleType, type IValidationContext, type IValidationResult, type Primitives, SimpleType, 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;

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Literal = void 0;
+exports.literal = literal;
+exports.isLiteralType = isLiteralType;
+const internal_ts_1 = require("../../internal.js");
+const utils_ts_1 = require("../../utils.js");
+/**
+ * @internal
+ * @hidden
+ */
+class Literal extends internal_ts_1.SimpleType {
+    value;
+    flags = internal_ts_1.TypeFlags.Literal;
+    constructor(value) {
+        super(JSON.stringify(value));
+        this.value = value;
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        return (0, internal_ts_1.createScalarNode)(this, parent, subpath, environment, initialValue);
+    }
+    describe() {
+        return JSON.stringify(this.value);
+    }
+    isValidSnapshot(value, context) {
+        if ((0, internal_ts_1.isPrimitive)(value) && value === this.value) {
+            return (0, internal_ts_1.typeCheckSuccess)();
+        }
+        return (0, internal_ts_1.typeCheckFailure)(context, value, `Value is not a literal ${JSON.stringify(this.value)}`);
+    }
+}
+exports.Literal = Literal;
+/**
+ * `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
+ */
+function literal(value) {
+    // check that the given value is a primitive
+    (0, utils_ts_1.assertArg)(value, internal_ts_1.isPrimitive, "primitive", 1);
+    return new Literal(value);
+}
+/**
+ * Returns if a given value represents a literal type.
+ *
+ * @param type
+ * @returns
+ */
+function isLiteralType(type) {
+    return (0, internal_ts_1.isType)(type) && (type.flags & internal_ts_1.TypeFlags.Literal) > 0;
+}
+//# sourceMappingURL=literal.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"literal.js","sourceRoot":"","sources":["../../../src/types/utility-types/literal.ts"],"names":[],"mappings":";;;AAyEA,0BAKC;AAQD,sCAIC;AA1FD,mDAa0B;AAC1B,6CAA0C;AAE1C;;;GAGG;AACH,MAAa,OAAW,SAAQ,wBAAmB;IACxC,KAAK,CAAG;IACR,KAAK,GAAG,uBAAS,CAAC,OAAO,CAAA;IAElC,YAAY,KAAQ;QAClB,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAA;QAC5B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;IACpB,CAAC;IAED,WAAW,CACT,MAA4B,EAC5B,OAAe,EACf,WAAgB,EAChB,YAAuB;QAEvB,OAAO,IAAA,8BAAgB,EAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,CAAC,CAAA;IAC3E,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACnC,CAAC;IAED,eAAe,CACb,KAAgB,EAChB,OAA2B;QAE3B,IAAI,IAAA,yBAAW,EAAC,KAAK,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YAC/C,OAAO,IAAA,8BAAgB,GAAE,CAAA;QAC3B,CAAC;QACD,OAAO,IAAA,8BAAgB,EACrB,OAAO,EACP,KAAK,EACL,0BAA0B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CACvD,CAAA;IACH,CAAC;CACF;AAnCD,0BAmCC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,OAAO,CAAuB,KAAQ;IACpD,4CAA4C;IAC5C,IAAA,oBAAS,EAAC,KAAK,EAAE,yBAAW,EAAE,WAAW,EAAE,CAAC,CAAC,CAAA;IAE7C,OAAO,IAAI,OAAO,CAAI,KAAK,CAAC,CAAA;AAC9B,CAAC;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAC3B,IAAQ;IAER,OAAO,IAAA,oBAAM,EAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,uBAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;AAC7D,CAAC"}

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

@@ -0,0 +1,26 @@
+import { type IAnyType, type IType } from "../../internal.ts";
+/** @hidden */
+export interface IMaybeIType<IT extends IAnyType, C, O> extends IType<IT["CreationType"] | C, IT["SnapshotType"] | O, IT["TypeWithoutSTN"] | O> {
+}
+/** @hidden */
+export interface IMaybe<IT extends IAnyType> extends IMaybeIType<IT, undefined, undefined> {
+}
+/** @hidden */
+export interface IMaybeNull<IT extends IAnyType> extends IMaybeIType<IT, null | undefined, null> {
+}
+/**
+ * `types.maybe` - Maybe will make a type nullable, and also optional.
+ * The value `undefined` will be used to represent nullability.
+ *
+ * @param type
+ * @returns
+ */
+export declare function maybe<IT extends IAnyType>(type: IT): IMaybe<IT>;
+/**
+ * `types.maybeNull` - Maybe will make a type nullable, and also optional.
+ * The value `null` will be used to represent no value.
+ *
+ * @param type
+ * @returns
+ */
+export declare function maybeNull<IT extends IAnyType>(type: IT): IMaybeNull<IT>;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybe = maybe;
+exports.maybeNull = maybeNull;
+const internal_ts_1 = require("../../internal.js");
+const optionalUndefinedType = (0, internal_ts_1.optional)(internal_ts_1.undefinedType, undefined);
+const optionalNullType = (0, internal_ts_1.optional)(internal_ts_1.nullType, null);
+/**
+ * `types.maybe` - Maybe will make a type nullable, and also optional.
+ * The value `undefined` will be used to represent nullability.
+ *
+ * @param type
+ * @returns
+ */
+function maybe(type) {
+    (0, internal_ts_1.assertIsType)(type, 1);
+    return (0, internal_ts_1.union)(type, optionalUndefinedType);
+}
+/**
+ * `types.maybeNull` - Maybe will make a type nullable, and also optional.
+ * The value `null` will be used to represent no value.
+ *
+ * @param type
+ * @returns
+ */
+function maybeNull(type) {
+    (0, internal_ts_1.assertIsType)(type, 1);
+    return (0, internal_ts_1.union)(type, optionalNullType);
+}
+//# sourceMappingURL=maybe.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"maybe.js","sourceRoot":"","sources":["../../../src/types/utility-types/maybe.ts"],"names":[],"mappings":";;AAyCA,sBAIC;AASD,8BAIC;AA1DD,mDAQ0B;AAE1B,MAAM,qBAAqB,GAAG,IAAA,sBAAQ,EAAC,2BAAa,EAAE,SAAS,CAAC,CAAA;AAChE,MAAM,gBAAgB,GAAG,IAAA,sBAAQ,EAAC,sBAAQ,EAAE,IAAI,CAAC,CAAA;AAuBjD;;;;;;GAMG;AACH,SAAgB,KAAK,CAAsB,IAAQ;IACjD,IAAA,0BAAY,EAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IAErB,OAAO,IAAA,mBAAK,EAAC,IAAI,EAAE,qBAAqB,CAAC,CAAA;AAC3C,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,SAAS,CAAsB,IAAQ;IACrD,IAAA,0BAAY,EAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IAErB,OAAO,IAAA,mBAAK,EAAC,IAAI,EAAE,gBAAgB,CAAC,CAAA;AACtC,CAAC"}

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

@@ -0,0 +1,41 @@
+import { type AnyObjectNode, BaseType, type ExtractCSTWithSTN, type IAnyType, type IType, type IValidationContext, type IValidationResult } from "../../internal.ts";
+type IFunctionReturn<T> = () => T;
+type IOptionalValue<C, T> = C | IFunctionReturn<C | T>;
+/** @hidden */
+export type ValidOptionalValue = string | boolean | number | null | undefined;
+/** @hidden */
+export type ValidOptionalValues = [ValidOptionalValue, ...ValidOptionalValue[]];
+/**
+ * @hidden
+ * @internal
+ */
+export declare class OptionalValue<IT extends IAnyType, OptionalVals extends ValidOptionalValues> extends BaseType<IT["CreationType"] | OptionalVals[number], IT["SnapshotType"], IT["TypeWithoutSTN"]> {
+    private readonly _subtype;
+    private readonly _defaultValue;
+    readonly optionalValues: OptionalVals;
+    get flags(): number;
+    constructor(_subtype: IT, _defaultValue: IOptionalValue<IT["CreationType"], IT["Type"]>, optionalValues: OptionalVals);
+    describe(): string;
+    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: this["C"] | this["T"]): this["N"];
+    reconcile(current: this["N"], newValue: this["C"] | this["T"], parent: AnyObjectNode, subpath: string): this["N"];
+    getDefaultInstanceOrSnapshot(): this["C"] | this["T"];
+    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
+    isAssignableFrom(type: IAnyType): boolean;
+    getSubTypes(): IT;
+}
+/** @hidden */
+export type OptionalDefaultValueOrFunction<IT extends IAnyType> = IT["CreationType"] | IT["SnapshotType"] | (() => ExtractCSTWithSTN<IT>);
+/** @hidden */
+export interface IOptionalIType<IT extends IAnyType, OptionalVals extends ValidOptionalValues> extends IType<IT["CreationType"] | OptionalVals[number], IT["SnapshotType"], IT["TypeWithoutSTN"]> {
+}
+export declare function optional<IT extends IAnyType>(type: IT, defaultValueOrFunction: OptionalDefaultValueOrFunction<IT>): IOptionalIType<IT, [undefined]>;
+export declare function optional<IT extends IAnyType, OptionalVals extends ValidOptionalValues>(type: IT, defaultValueOrFunction: OptionalDefaultValueOrFunction<IT>, optionalValues: OptionalVals): IOptionalIType<IT, OptionalVals>;
+/**
+ * Returns if a value represents an optional type.
+ *
+ * @template IT
+ * @param type
+ * @returns
+ */
+export declare function isOptionalType<IT extends IAnyType>(type: IT): type is IT;
+export {};