@jbrowse/mobx-state-tree 5.6.3 → 5.6.9

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalValue = void 0;
+exports.optional = optional;
+exports.isOptionalType = isOptionalType;
+const internal_ts_1 = require("../../internal.js");
+/**
+ * @hidden
+ * @internal
+ */
+class OptionalValue extends internal_ts_1.BaseType {
+    _subtype;
+    _defaultValue;
+    optionalValues;
+    get flags() {
+        return this._subtype.flags | internal_ts_1.TypeFlags.Optional;
+    }
+    constructor(_subtype, _defaultValue, optionalValues) {
+        super(_subtype.name);
+        this._subtype = _subtype;
+        this._defaultValue = _defaultValue;
+        this.optionalValues = optionalValues;
+    }
+    describe() {
+        return this._subtype.describe() + "?";
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        if (this.optionalValues.indexOf(initialValue) >= 0) {
+            const defaultInstanceOrSnapshot = this.getDefaultInstanceOrSnapshot();
+            return this._subtype.instantiate(parent, subpath, environment, defaultInstanceOrSnapshot);
+        }
+        return this._subtype.instantiate(parent, subpath, environment, initialValue);
+    }
+    reconcile(current, newValue, parent, subpath) {
+        return this._subtype.reconcile(current, this.optionalValues.indexOf(newValue) < 0 && this._subtype.is(newValue)
+            ? newValue
+            : this.getDefaultInstanceOrSnapshot(), parent, subpath);
+    }
+    getDefaultInstanceOrSnapshot() {
+        const defaultInstanceOrSnapshot = typeof this._defaultValue === "function"
+            ? this._defaultValue()
+            : this._defaultValue;
+        // while static values are already snapshots and checked on types.optional
+        // generator functions must always be rechecked just in case
+        if (typeof this._defaultValue === "function") {
+            (0, internal_ts_1.typecheckInternal)(this, defaultInstanceOrSnapshot);
+        }
+        return defaultInstanceOrSnapshot;
+    }
+    isValidSnapshot(value, context) {
+        // defaulted values can be skipped
+        if (this.optionalValues.indexOf(value) >= 0) {
+            return (0, internal_ts_1.typeCheckSuccess)();
+        }
+        // bounce validation to the sub-type
+        return this._subtype.validate(value, context);
+    }
+    isAssignableFrom(type) {
+        return this._subtype.isAssignableFrom(type);
+    }
+    getSubTypes() {
+        return this._subtype;
+    }
+}
+exports.OptionalValue = OptionalValue;
+function checkOptionalPreconditions(type, defaultValueOrFunction) {
+    // make sure we never pass direct instances
+    if (typeof defaultValueOrFunction !== "function" &&
+        (0, internal_ts_1.isStateTreeNode)(defaultValueOrFunction)) {
+        throw (0, internal_ts_1.fail)("default value cannot be an instance, pass a snapshot or a function that creates an instance/snapshot instead");
+    }
+    (0, internal_ts_1.assertIsType)(type, 1);
+    if ((0, internal_ts_1.devMode)()) {
+        // we only check default values if they are passed directly
+        // if they are generator functions they will be checked once they are generated
+        // we don't check generator function results here to avoid generating a node just for type-checking purposes
+        // which might generate side-effects
+        if (typeof defaultValueOrFunction !== "function") {
+            (0, internal_ts_1.typecheckInternal)(type, defaultValueOrFunction);
+        }
+    }
+}
+/**
+ * `types.optional` - Can be used to create a property with a default value.
+ *
+ * Depending on the third argument (`optionalValues`) there are two ways of operation:
+ * - If the argument is not provided, then if a value is not provided in the snapshot (`undefined` or missing),
+ *   it will default to the provided `defaultValue`
+ * - If the argument is provided, then if the value in the snapshot matches one of the optional values inside the array then it will
+ *   default to the provided `defaultValue`. Additionally, if one of the optional values inside the array is `undefined` then a missing
+ *   property is also valid.
+ *
+ *   Note that it is also possible to include values of the same type as the intended subtype as optional values,
+ *   in this case the optional value will be transformed into the `defaultValue` (e.g. `types.optional(types.string, "unnamed", [undefined, ""])`
+ *   will transform the snapshot values `undefined` (and therefore missing) and empty strings into the string `"unnamed"` when it gets
+ *   instantiated).
+ *
+ * If `defaultValue` is a function, the function will be invoked for every new instance.
+ * Applying a snapshot in which the optional value is one of the optional values (or `undefined`/_not_ present if none are provided) causes the
+ * value to be reset.
+ *
+ * Example:
+ * ```ts
+ * const Todo = types.model({
+ *   title: types.string,
+ *   subtitle1: types.optional(types.string, "", [null]),
+ *   subtitle2: types.optional(types.string, "", [null, undefined]),
+ *   done: types.optional(types.boolean, false),
+ *   created: types.optional(types.Date, () => new Date()),
+ * })
+ *
+ * // if done is missing / undefined it will become false
+ * // if created is missing / undefined it will get a freshly generated timestamp
+ * // if subtitle1 is null it will default to "", but it cannot be missing or undefined
+ * // if subtitle2 is null or undefined it will default to ""; since it can be undefined it can also be missing
+ * const todo = Todo.create({ title: "Get coffee", subtitle1: null })
+ * ```
+ *
+ * @param type
+ * @param defaultValueOrFunction
+ * @param optionalValues an optional array with zero or more primitive values (string, number, boolean, null or undefined)
+ *                       that will be converted into the default. `[ undefined ]` is assumed when none is provided
+ * @returns
+ */
+function optional(type, defaultValueOrFunction, optionalValues) {
+    checkOptionalPreconditions(type, defaultValueOrFunction);
+    return new OptionalValue(type, defaultValueOrFunction, optionalValues ? optionalValues : undefinedAsOptionalValues);
+}
+const undefinedAsOptionalValues = [undefined];
+/**
+ * Returns if a value represents an optional type.
+ *
+ * @template IT
+ * @param type
+ * @returns
+ */
+function isOptionalType(type) {
+    return (0, internal_ts_1.isType)(type) && (type.flags & internal_ts_1.TypeFlags.Optional) > 0;
+}
+//# sourceMappingURL=optional.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optional.js","sourceRoot":"","sources":["../../../src/types/utility-types/optional.ts"],"names":[],"mappings":";;;AAgOA,4BAeC;AAWD,wCAEC;AA5PD,mDAgB0B;AAY1B;;;GAGG;AACH,MAAa,aAGX,SAAQ,sBAIT;IAMoB;IACA;IAIR;IAVX,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,uBAAS,CAAC,QAAQ,CAAA;IACjD,CAAC;IAED,YACmB,QAAY,EACZ,aAGhB,EACQ,cAA4B;QAErC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QAPH,aAAQ,GAAR,QAAQ,CAAI;QACZ,kBAAa,GAAb,aAAa,CAG7B;QACQ,mBAAc,GAAd,cAAc,CAAc;IAGvC,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,GAAG,GAAG,CAAA;IACvC,CAAC;IAED,WAAW,CACT,MAA4B,EAC5B,OAAe,EACf,WAAgB,EAChB,YAAmC;QAEnC,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;YACnD,MAAM,yBAAyB,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAA;YACrE,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAC9B,MAAM,EACN,OAAO,EACP,WAAW,EACX,yBAAyB,CAC1B,CAAA;QACH,CAAC;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,CAAC,CAAA;IAC9E,CAAC;IAED,SAAS,CACP,OAAkB,EAClB,QAA+B,EAC/B,MAAqB,EACrB,OAAe;QAEf,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,CAC5B,OAAO,EACP,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC;YACrE,CAAC,CAAC,QAAQ;YACV,CAAC,CAAC,IAAI,CAAC,4BAA4B,EAAE,EACvC,MAAM,EACN,OAAO,CACR,CAAA;IACH,CAAC;IAED,4BAA4B;QAC1B,MAAM,yBAAyB,GAC7B,OAAO,IAAI,CAAC,aAAa,KAAK,UAAU;YACtC,CAAC,CAAE,IAAI,CAAC,aAAwD,EAAE;YAClE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAA;QAExB,0EAA0E;QAC1E,4DAA4D;QAC5D,IAAI,OAAO,IAAI,CAAC,aAAa,KAAK,UAAU,EAAE,CAAC;YAC7C,IAAA,+BAAiB,EAAC,IAAI,EAAE,yBAAyB,CAAC,CAAA;QACpD,CAAC;QAED,OAAO,yBAAyB,CAAA;IAClC,CAAC;IAED,eAAe,CACb,KAAgB,EAChB,OAA2B;QAE3B,kCAAkC;QAClC,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5C,OAAO,IAAA,8BAAgB,GAAE,CAAA;QAC3B,CAAC;QACD,oCAAoC;QACpC,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;IAC/C,CAAC;IAED,gBAAgB,CAAC,IAAc;QAC7B,OAAO,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAA;IAC7C,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAA;IACtB,CAAC;CACF;AA/FD,sCA+FC;AAkBD,SAAS,0BAA0B,CACjC,IAAc,EACd,sBAA0D;IAE1D,2CAA2C;IAC3C,IACE,OAAO,sBAAsB,KAAK,UAAU;QAC5C,IAAA,6BAAe,EAAC,sBAAsB,CAAC,EACvC,CAAC;QACD,MAAM,IAAA,kBAAI,EACR,8GAA8G,CAC/G,CAAA;IACH,CAAC;IACD,IAAA,0BAAY,EAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IACrB,IAAI,IAAA,qBAAO,GAAE,EAAE,CAAC;QACd,2DAA2D;QAC3D,+EAA+E;QAC/E,4GAA4G;QAC5G,oCAAoC;QACpC,IAAI,OAAO,sBAAsB,KAAK,UAAU,EAAE,CAAC;YACjD,IAAA,+BAAiB,EAAC,IAAI,EAAE,sBAAsB,CAAC,CAAA;QACjD,CAAC;IACH,CAAC;AACH,CAAC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,SAAgB,QAAQ,CAItB,IAAQ,EACR,sBAA0D,EAC1D,cAA6B;IAE7B,0BAA0B,CAAC,IAAI,EAAE,sBAAsB,CAAC,CAAA;IAExD,OAAO,IAAI,aAAa,CACtB,IAAI,EACJ,sBAAsB,EACtB,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,yBAAyB,CAC5D,CAAA;AACH,CAAC;AAED,MAAM,yBAAyB,GAAgB,CAAC,SAAS,CAAC,CAAA;AAE1D;;;;;;GAMG;AACH,SAAgB,cAAc,CAAsB,IAAQ;IAC1D,OAAO,IAAA,oBAAM,EAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,uBAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAA;AAC9D,CAAC"}

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

@@ -0,0 +1,89 @@
+import { type AnyObjectNode, type IAnyComplexType, type IAnyStateTreeNode, type IAnyType, type IMaybe, type IStateTreeNode, type IType, type IValidationContext, type IValidationResult, type ReferenceIdentifier, SimpleType, TypeFlags } from "../../internal.ts";
+export type OnReferenceInvalidatedEvent<STN extends IAnyStateTreeNode> = {
+    parent: IAnyStateTreeNode;
+    invalidTarget: STN | undefined;
+    invalidId: ReferenceIdentifier;
+    replaceRef: (newRef: STN | null | undefined) => void;
+    removeRef: () => void;
+    cause: "detach" | "destroy" | "invalidSnapshotReference";
+};
+export type OnReferenceInvalidated<STN extends IAnyStateTreeNode> = (event: OnReferenceInvalidatedEvent<STN>) => void;
+/** @hidden */
+export type ReferenceT<IT extends IAnyType> = IT["TypeWithoutSTN"] & IStateTreeNode<IReferenceType<IT>>;
+/**
+ * @internal
+ * @hidden
+ */
+export declare class InvalidReferenceError extends Error {
+    constructor(m: string);
+}
+/**
+ * @internal
+ * @hidden
+ */
+export declare abstract class BaseReferenceType<IT extends IAnyComplexType> extends SimpleType<ReferenceIdentifier, ReferenceIdentifier, IT["TypeWithoutSTN"]> {
+    protected readonly targetType: IT;
+    private readonly onInvalidated?;
+    readonly flags = TypeFlags.Reference;
+    constructor(targetType: IT, onInvalidated?: OnReferenceInvalidated<ReferenceT<IT>> | undefined);
+    describe(): string;
+    isAssignableFrom(type: IAnyType): boolean;
+    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
+    private fireInvalidated;
+    private addTargetNodeWatcher;
+    protected watchTargetNodeForInvalidations(storedRefNode: this["N"], identifier: ReferenceIdentifier, customGetSet: ReferenceOptionsGetSet<IT> | undefined): void;
+}
+/**
+ * @internal
+ * @hidden
+ */
+export declare class IdentifierReferenceType<IT extends IAnyComplexType> extends BaseReferenceType<IT> {
+    constructor(targetType: IT, onInvalidated?: OnReferenceInvalidated<ReferenceT<IT>>);
+    getValue(storedRefNode: this["N"]): any;
+    getSnapshot(storedRefNode: this["N"]): ReferenceIdentifier;
+    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"];
+}
+/**
+ * @internal
+ * @hidden
+ */
+export declare class CustomReferenceType<IT extends IAnyComplexType> extends BaseReferenceType<IT> {
+    private readonly options;
+    constructor(targetType: IT, options: ReferenceOptionsGetSet<IT>, onInvalidated?: OnReferenceInvalidated<ReferenceT<IT>>);
+    getValue(storedRefNode: this["N"]): any;
+    getSnapshot(storedRefNode: this["N"]): any;
+    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, newValue: this["C"] | this["T"]): this["N"];
+    reconcile(current: this["N"], newValue: this["C"] | this["T"], parent: AnyObjectNode, subpath: string): this["N"];
+}
+export interface ReferenceOptionsGetSet<IT extends IAnyComplexType> {
+    get(identifier: ReferenceIdentifier, parent: IAnyStateTreeNode | null): ReferenceT<IT>;
+    set(value: ReferenceT<IT>, parent: IAnyStateTreeNode | null): ReferenceIdentifier;
+}
+export interface ReferenceOptionsOnInvalidated<IT extends IAnyComplexType> {
+    onInvalidated: OnReferenceInvalidated<ReferenceT<IT>>;
+}
+export type ReferenceOptions<IT extends IAnyComplexType> = ReferenceOptionsGetSet<IT> | ReferenceOptionsOnInvalidated<IT> | (ReferenceOptionsGetSet<IT> & ReferenceOptionsOnInvalidated<IT>);
+/** @hidden */
+export interface IReferenceType<IT extends IAnyComplexType> extends IType<ReferenceIdentifier, ReferenceIdentifier, IT["TypeWithoutSTN"]> {
+}
+/**
+ * `types.reference` - Creates a reference to another type, which should have defined an identifier.
+ * See also the [reference and identifiers](https://github.com/mobxjs/mobx-state-tree#references-and-identifiers) section.
+ */
+export declare function reference<IT extends IAnyComplexType>(subType: IT, options?: ReferenceOptions<IT>): IReferenceType<IT>;
+/**
+ * Returns if a given value represents a reference type.
+ *
+ * @param type
+ * @returns
+ */
+export declare function isReferenceType<IT extends IReferenceType<any>>(type: IT): type is IT;
+export declare function safeReference<IT extends IAnyComplexType>(subType: IT, options: (ReferenceOptionsGetSet<IT> | object) & {
+    acceptsUndefined: false;
+    onInvalidated?: OnReferenceInvalidated<ReferenceT<IT>>;
+}): IReferenceType<IT>;
+export declare function safeReference<IT extends IAnyComplexType>(subType: IT, options?: (ReferenceOptionsGetSet<IT> | object) & {
+    acceptsUndefined?: boolean;
+    onInvalidated?: OnReferenceInvalidated<ReferenceT<IT>>;
+}): IMaybe<IReferenceType<IT>>;

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

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomReferenceType = exports.IdentifierReferenceType = exports.BaseReferenceType = exports.InvalidReferenceError = void 0;
+exports.reference = reference;
+exports.isReferenceType = isReferenceType;
+exports.safeReference = safeReference;
+const internal_ts_1 = require("../../internal.js");
+function getInvalidationCause(hook) {
+    switch (hook) {
+        case internal_ts_1.Hook.beforeDestroy:
+            return "destroy";
+        case internal_ts_1.Hook.beforeDetach:
+            return "detach";
+        default:
+            return undefined;
+    }
+}
+class StoredReference {
+    targetType;
+    identifier;
+    node;
+    resolvedReference;
+    constructor(value, targetType) {
+        this.targetType = targetType;
+        if ((0, internal_ts_1.isValidIdentifier)(value)) {
+            this.identifier = value;
+        }
+        else if ((0, internal_ts_1.isStateTreeNode)(value)) {
+            const targetNode = (0, internal_ts_1.getStateTreeNode)(value);
+            if (!targetNode.identifierAttribute) {
+                throw (0, internal_ts_1.fail)(`Can only store references with a defined identifier attribute.`);
+            }
+            const id = targetNode.unnormalizedIdentifier;
+            if (id === null || id === undefined) {
+                throw (0, internal_ts_1.fail)(`Can only store references to tree nodes with a defined identifier.`);
+            }
+            this.identifier = id;
+        }
+        else {
+            throw (0, internal_ts_1.fail)(`Can only store references to tree nodes or identifiers, got: '${value}'`);
+        }
+    }
+    updateResolvedReference(node) {
+        const normalizedId = (0, internal_ts_1.normalizeIdentifier)(this.identifier);
+        const root = node.root;
+        const lastCacheModification = root.identifierCache.getLastCacheModificationPerId(normalizedId);
+        if (!this.resolvedReference ||
+            this.resolvedReference.lastCacheModification !== lastCacheModification) {
+            const { targetType } = this;
+            // reference was initialized with the identifier of the target
+            const target = root.identifierCache.resolve(targetType, normalizedId);
+            if (!target) {
+                throw new InvalidReferenceError(`[mobx-state-tree] Failed to resolve reference '${this.identifier}' to type '${this.targetType.name}' (from node: ${node.path})`);
+            }
+            this.resolvedReference = {
+                node: target,
+                lastCacheModification: lastCacheModification
+            };
+        }
+    }
+    get resolvedValue() {
+        this.updateResolvedReference(this.node);
+        return this.resolvedReference.node.value;
+    }
+}
+/**
+ * @internal
+ * @hidden
+ */
+class InvalidReferenceError extends Error {
+    constructor(m) {
+        super(m);
+        Object.setPrototypeOf(this, InvalidReferenceError.prototype);
+    }
+}
+exports.InvalidReferenceError = InvalidReferenceError;
+/**
+ * @internal
+ * @hidden
+ */
+class BaseReferenceType extends internal_ts_1.SimpleType {
+    targetType;
+    onInvalidated;
+    flags = internal_ts_1.TypeFlags.Reference;
+    constructor(targetType, onInvalidated) {
+        super(`reference(${targetType.name})`);
+        this.targetType = targetType;
+        this.onInvalidated = onInvalidated;
+    }
+    describe() {
+        return this.name;
+    }
+    isAssignableFrom(type) {
+        return this.targetType.isAssignableFrom(type);
+    }
+    isValidSnapshot(value, context) {
+        return (0, internal_ts_1.isValidIdentifier)(value)
+            ? (0, internal_ts_1.typeCheckSuccess)()
+            : (0, internal_ts_1.typeCheckFailure)(context, value, "Value is not a valid identifier, which is a string or a number");
+    }
+    fireInvalidated(cause, storedRefNode, referenceId, refTargetNode) {
+        // to actually invalidate a reference we need an alive parent,
+        // since it is a scalar value (immutable-ish) and we need to change it
+        // from the parent
+        const storedRefParentNode = storedRefNode.parent;
+        if (!storedRefParentNode || !storedRefParentNode.isAlive) {
+            return;
+        }
+        const storedRefParentValue = storedRefParentNode.storedValue;
+        if (!storedRefParentValue) {
+            return;
+        }
+        this.onInvalidated({
+            cause,
+            parent: storedRefParentValue,
+            invalidTarget: refTargetNode ? refTargetNode.storedValue : undefined,
+            invalidId: referenceId,
+            replaceRef(newRef) {
+                (0, internal_ts_1.applyPatch)(storedRefNode.root.storedValue, {
+                    op: "replace",
+                    value: newRef,
+                    path: storedRefNode.path
+                });
+            },
+            removeRef() {
+                if ((0, internal_ts_1.isModelType)(storedRefParentNode.type)) {
+                    this.replaceRef(undefined);
+                }
+                else {
+                    (0, internal_ts_1.applyPatch)(storedRefNode.root.storedValue, {
+                        op: "remove",
+                        path: storedRefNode.path
+                    });
+                }
+            }
+        });
+    }
+    addTargetNodeWatcher(storedRefNode, referenceId) {
+        // this will make sure the target node becomes created
+        const refTargetValue = this.getValue(storedRefNode);
+        if (!refTargetValue) {
+            return undefined;
+        }
+        const refTargetNode = (0, internal_ts_1.getStateTreeNode)(refTargetValue);
+        const hookHandler = (_, refTargetNodeHook) => {
+            const cause = getInvalidationCause(refTargetNodeHook);
+            if (!cause) {
+                return;
+            }
+            this.fireInvalidated(cause, storedRefNode, referenceId, refTargetNode);
+        };
+        const refTargetDetachHookDisposer = refTargetNode.registerHook(internal_ts_1.Hook.beforeDetach, hookHandler);
+        const refTargetDestroyHookDisposer = refTargetNode.registerHook(internal_ts_1.Hook.beforeDestroy, hookHandler);
+        return () => {
+            refTargetDetachHookDisposer();
+            refTargetDestroyHookDisposer();
+        };
+    }
+    watchTargetNodeForInvalidations(storedRefNode, identifier, customGetSet) {
+        if (!this.onInvalidated) {
+            return;
+        }
+        let onRefTargetDestroyedHookDisposer;
+        // get rid of the watcher hook when the stored ref node is destroyed
+        // detached is ignored since scalar nodes (where the reference resides) cannot be detached
+        storedRefNode.registerHook(internal_ts_1.Hook.beforeDestroy, () => {
+            if (onRefTargetDestroyedHookDisposer) {
+                onRefTargetDestroyedHookDisposer();
+            }
+        });
+        const startWatching = (sync) => {
+            // re-create hook in case the stored ref gets reattached
+            if (onRefTargetDestroyedHookDisposer) {
+                onRefTargetDestroyedHookDisposer();
+            }
+            // make sure the target node is actually there and initialized
+            const storedRefParentNode = storedRefNode.parent;
+            const storedRefParentValue = storedRefParentNode && storedRefParentNode.storedValue;
+            if (storedRefParentNode &&
+                storedRefParentNode.isAlive &&
+                storedRefParentValue) {
+                let refTargetNodeExists;
+                if (customGetSet) {
+                    refTargetNodeExists = !!customGetSet.get(identifier, storedRefParentValue);
+                }
+                else {
+                    refTargetNodeExists = storedRefNode.root.identifierCache.has(this.targetType, (0, internal_ts_1.normalizeIdentifier)(identifier));
+                }
+                if (!refTargetNodeExists) {
+                    // we cannot change the reference in sync mode
+                    // since we are in the middle of a reconciliation/instantiation and the change would be overwritten
+                    // for those cases just let the wrong reference be assigned and fail upon usage
+                    // (like current references do)
+                    // this means that effectively this code will only run when it is created from a snapshot
+                    if (!sync) {
+                        this.fireInvalidated("invalidSnapshotReference", storedRefNode, identifier, null);
+                    }
+                }
+                else {
+                    onRefTargetDestroyedHookDisposer = this.addTargetNodeWatcher(storedRefNode, identifier);
+                }
+            }
+        };
+        if (storedRefNode.state === internal_ts_1.NodeLifeCycle.FINALIZED) {
+            // already attached, so the whole tree is ready
+            startWatching(true);
+        }
+        else {
+            if (!storedRefNode.isRoot) {
+                // start watching once the whole tree is ready
+                storedRefNode.root.registerHook(internal_ts_1.Hook.afterCreationFinalization, () => {
+                    // make sure to attach it so it can start listening
+                    if (storedRefNode.parent) {
+                        storedRefNode.parent.createObservableInstanceIfNeeded();
+                    }
+                });
+            }
+            // start watching once the node is attached somewhere / parent changes
+            storedRefNode.registerHook(internal_ts_1.Hook.afterAttach, () => {
+                startWatching(false);
+            });
+        }
+    }
+}
+exports.BaseReferenceType = BaseReferenceType;
+/**
+ * @internal
+ * @hidden
+ */
+class IdentifierReferenceType extends BaseReferenceType {
+    constructor(targetType, onInvalidated) {
+        super(targetType, onInvalidated);
+    }
+    getValue(storedRefNode) {
+        if (!storedRefNode.isAlive) {
+            return undefined;
+        }
+        const storedRef = storedRefNode.storedValue;
+        return storedRef.resolvedValue;
+    }
+    getSnapshot(storedRefNode) {
+        const ref = storedRefNode.storedValue;
+        return ref.identifier;
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        const identifier = (0, internal_ts_1.isStateTreeNode)(initialValue)
+            ? (0, internal_ts_1.getIdentifier)(initialValue)
+            : initialValue;
+        const storedRef = new StoredReference(initialValue, this.targetType);
+        const storedRefNode = (0, internal_ts_1.createScalarNode)(this, parent, subpath, environment, storedRef);
+        storedRef.node = storedRefNode;
+        this.watchTargetNodeForInvalidations(storedRefNode, identifier, undefined);
+        return storedRefNode;
+    }
+    reconcile(current, newValue, parent, subpath) {
+        if (!current.isDetaching && current.type === this) {
+            const compareByValue = (0, internal_ts_1.isStateTreeNode)(newValue);
+            const ref = current.storedValue;
+            if ((!compareByValue && ref.identifier === newValue) ||
+                (compareByValue && ref.resolvedValue === newValue)) {
+                current.setParent(parent, subpath);
+                return current;
+            }
+        }
+        const newNode = this.instantiate(parent, subpath, undefined, newValue);
+        current.die(); // noop if detaching
+        return newNode;
+    }
+}
+exports.IdentifierReferenceType = IdentifierReferenceType;
+/**
+ * @internal
+ * @hidden
+ */
+class CustomReferenceType extends BaseReferenceType {
+    options;
+    constructor(targetType, options, onInvalidated) {
+        super(targetType, onInvalidated);
+        this.options = options;
+    }
+    getValue(storedRefNode) {
+        if (!storedRefNode.isAlive) {
+            return undefined;
+        }
+        const referencedNode = this.options.get(storedRefNode.storedValue, storedRefNode.parent ? storedRefNode.parent.storedValue : null);
+        return referencedNode;
+    }
+    getSnapshot(storedRefNode) {
+        return storedRefNode.storedValue;
+    }
+    instantiate(parent, subpath, environment, newValue) {
+        const identifier = (0, internal_ts_1.isStateTreeNode)(newValue)
+            ? this.options.set(newValue, parent ? parent.storedValue : null)
+            : newValue;
+        const storedRefNode = (0, internal_ts_1.createScalarNode)(this, parent, subpath, environment, identifier);
+        this.watchTargetNodeForInvalidations(storedRefNode, identifier, this.options);
+        return storedRefNode;
+    }
+    reconcile(current, newValue, parent, subpath) {
+        const newIdentifier = (0, internal_ts_1.isStateTreeNode)(newValue)
+            ? this.options.set(newValue, current ? current.storedValue : null)
+            : newValue;
+        if (!current.isDetaching &&
+            current.type === this &&
+            current.storedValue === newIdentifier) {
+            current.setParent(parent, subpath);
+            return current;
+        }
+        const newNode = this.instantiate(parent, subpath, undefined, newIdentifier);
+        current.die(); // noop if detaching
+        return newNode;
+    }
+}
+exports.CustomReferenceType = CustomReferenceType;
+/**
+ * `types.reference` - Creates a reference to another type, which should have defined an identifier.
+ * See also the [reference and identifiers](https://github.com/mobxjs/mobx-state-tree#references-and-identifiers) section.
+ */
+function reference(subType, options) {
+    (0, internal_ts_1.assertIsType)(subType, 1);
+    if ((0, internal_ts_1.devMode)()) {
+        if (options && typeof options === "string") {
+            // istanbul ignore next
+            throw (0, internal_ts_1.fail)("References with base path are no longer supported. Please remove the base path.");
+        }
+    }
+    const getSetOptions = options
+        ? options
+        : undefined;
+    const onInvalidated = options
+        ? options.onInvalidated
+        : undefined;
+    if (getSetOptions && (getSetOptions.get || getSetOptions.set)) {
+        if ((0, internal_ts_1.devMode)()) {
+            if (!getSetOptions.get || !getSetOptions.set) {
+                throw (0, internal_ts_1.fail)("reference options must either contain both a 'get' and a 'set' method or none of them");
+            }
+        }
+        return new CustomReferenceType(subType, {
+            get: getSetOptions.get,
+            set: getSetOptions.set
+        }, onInvalidated);
+    }
+    else {
+        return new IdentifierReferenceType(subType, onInvalidated);
+    }
+}
+/**
+ * Returns if a given value represents a reference type.
+ *
+ * @param type
+ * @returns
+ */
+function isReferenceType(type) {
+    return (type.flags & internal_ts_1.TypeFlags.Reference) > 0;
+}
+/**
+ * `types.safeReference` - A safe reference is like a standard reference, except that it accepts the undefined value by default
+ * and automatically sets itself to undefined (when the parent is a model) / removes itself from arrays and maps
+ * when the reference it is pointing to gets detached/destroyed.
+ *
+ * The optional options parameter object accepts a parameter named `acceptsUndefined`, which is set to true by default, so it is suitable
+ * for model properties.
+ * When used inside collections (arrays/maps), it is recommended to set this option to false so it can't take undefined as value,
+ * which is usually the desired in those cases.
+ * Additionally, the optional options parameter object accepts a parameter named `onInvalidated`, which will be called when the reference target node that the reference is pointing to is about to be detached/destroyed
+ *
+ * Strictly speaking it is a `types.maybe(types.reference(X))` (when `acceptsUndefined` is set to true, the default) and
+ * `types.reference(X)` (when `acceptsUndefined` is set to false), both of them with a customized `onInvalidated` option.
+ *
+ * @param subType
+ * @param options
+ * @returns
+ */
+function safeReference(subType, options) {
+    const refType = reference(subType, {
+        ...options,
+        onInvalidated(ev) {
+            if (options && options.onInvalidated) {
+                options.onInvalidated(ev);
+            }
+            ev.removeRef();
+        }
+    });
+    if (options && options.acceptsUndefined === false) {
+        return refType;
+    }
+    else {
+        return (0, internal_ts_1.maybe)(refType);
+    }
+}
+//# sourceMappingURL=reference.js.map

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

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

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

@@ -0,0 +1,10 @@
+import { type IAnyType } from "../../internal.ts";
+export declare function refinement<IT extends IAnyType>(name: string, type: IT, predicate: (snapshot: IT["CreationType"]) => boolean, message?: string | ((v: IT["CreationType"]) => string)): IT;
+export declare function refinement<IT extends IAnyType>(type: IT, predicate: (snapshot: IT["CreationType"]) => boolean, message?: string | ((v: IT["CreationType"]) => string)): IT;
+/**
+ * Returns if a given value is a refinement type.
+ *
+ * @param type
+ * @returns
+ */
+export declare function isRefinementType<IT extends IAnyType>(type: IT): type is IT;