mobx-state-tree 7.1.0 → 7.3.0

package/dist/core/type/errorFormatting.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Options that control how snapshots/values and type shapes are rendered inside
+ * type-checking error messages (see {@link setErrorFormatting}).
+ */
+export interface ErrorFormattingOptions {
+    /**
+     * When `false` (the default), error messages are rendered exactly as they
+     * always have been: the offending value is serialized to a single
+     * `JSON.stringify` line and the message is capped in length. When `true`,
+     * the value is truncated (using the limits below) and, when `indent > 0`,
+     * pretty-printed across multiple lines.
+     */
+    enabled: boolean;
+    /**
+     * Number of spaces to indent each nesting level by when pretty-printing.
+     * Use `0` to keep everything on a single line while still truncating
+     * (handy when you only want to bound the message size, not reflow it).
+     */
+    indent: number;
+    /** Strings longer than this are clipped, with a note of how many characters were omitted. */
+    maxStringLength: number;
+    /** Arrays with more than this many items are clipped, with a note of how many items were omitted. */
+    maxArrayLength: number;
+    /** Objects with more than this many keys are clipped, with a note of how many keys were omitted. */
+    maxPropertyCount: number;
+    /** Values nested deeper than this are summarized as `{…}` / `[…]`. */
+    maxDepth: number;
+}
+/**
+ * Configures how snapshots/values and type shapes are formatted inside
+ * type-checking error messages. This is **opt-in**: by default MST keeps its
+ * original single-line error formatting, so enabling this does not change
+ * behavior for anyone who doesn't call it.
+ *
+ * The given options are merged over the current ones, so you can set only the
+ * fields you care about.
+ *
+ * @example
+ * // pretty-print large snapshots across multiple lines and truncate them
+ * setErrorFormatting({ enabled: true })
+ *
+ * @example
+ * // only bound the message size, without reflowing it onto multiple lines
+ * setErrorFormatting({ enabled: true, indent: 0 })
+ *
+ * @example
+ * // tweak the truncation limits
+ * setErrorFormatting({ enabled: true, maxArrayLength: 3, maxStringLength: 40 })
+ *
+ * @param options A partial set of {@link ErrorFormattingOptions} to apply.
+ */
+export declare function setErrorFormatting(options: Partial<ErrorFormattingOptions>): void;
+/**
+ * Returns a copy of the current error formatting options (see
+ * {@link setErrorFormatting}). Useful for temporarily overriding and then
+ * restoring the configuration.
+ *
+ * @returns The current {@link ErrorFormattingOptions}.
+ */
+export declare function getErrorFormatting(): ErrorFormattingOptions;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { type IModelType, type IAnyModelType, type IDisposer, type IMSTMap, type IMapType, type IMSTArray, type IArrayType, type IType, type IAnyType, type ModelPrimitive, type ISimpleType, type IComplexType, type IAnyComplexType, type IReferenceType, type _CustomCSProcessor, type _CustomOrOther, type _CustomJoin, type _NotCustomized, typecheck, escapeJsonPath, unescapeJsonPath, joinJsonPath, splitJsonPath, type IJsonPatch, type IReversibleJsonPatch, decorate, addMiddleware, type IMiddlewareEvent, type IActionTrackingMiddleware2Call, type IMiddlewareHandler, type IMiddlewareEventType, type IActionTrackingMiddlewareHooks, type IActionTrackingMiddleware2Hooks, process, isStateTreeNode, type IStateTreeNode, type IAnyStateTreeNode, flow, castFlowReturn, applyAction, onAction, type IActionRecorder, type ISerializedActionCall, recordActions, createActionTrackingMiddleware, createActionTrackingMiddleware2, setLivelinessChecking, getLivelinessChecking, type LivelinessMode, setLivelynessChecking, // to be deprecated
+export { type IModelType, type IAnyModelType, type IDisposer, type IMSTMap, type IMapType, type IMSTArray, type IArrayType, type IType, type IAnyType, type ModelPrimitive, type ISimpleType, type IComplexType, type IAnyComplexType, type IReferenceType, type _CustomCSProcessor, type _CustomOrOther, type _CustomJoin, type _NotCustomized, typecheck, escapeJsonPath, unescapeJsonPath, joinJsonPath, splitJsonPath, type IJsonPatch, type IReversibleJsonPatch, decorate, addMiddleware, type IMiddlewareEvent, type IActionTrackingMiddleware2Call, type IMiddlewareHandler, type IMiddlewareEventType, type IActionTrackingMiddlewareHooks, type IActionTrackingMiddleware2Hooks, process, isStateTreeNode, type IStateTreeNode, type IAnyStateTreeNode, flow, castFlowReturn, applyAction, onAction, type IActionRecorder, type ISerializedActionCall, recordActions, createActionTrackingMiddleware, createActionTrackingMiddleware2, setLivelinessChecking, getLivelinessChecking, type LivelinessMode, setErrorFormatting, getErrorFormatting, type ErrorFormattingOptions, setLivelynessChecking, // to be deprecated
 type LivelynessMode, // to be deprecated
 type ModelSnapshotType, type ModelCreationType, type ModelSnapshotType2, type ModelCreationType2, type ModelInstanceType, type ModelInstanceTypeProps, type ModelPropertiesDeclarationToProperties, type ModelProperties, type ModelPropertiesDeclaration, type ModelActions, type ITypeUnion, type CustomTypeOptions, type UnionOptions, type Instance, type SnapshotIn, type SnapshotOut, type SnapshotOrInstance, type TypeOrStateTreeNodeToStateTreeNode, type UnionStringArray, getType, getChildType, onPatch, onSnapshot, applyPatch, type IPatchRecorder, recordPatches, protect, unprotect, isProtected, applySnapshot, getSnapshot, hasParent, getParent, hasParentOfType, getParentOfType, getRoot, getPath, getPathParts, isRoot, resolvePath, resolveIdentifier, getIdentifier, tryResolve, getRelativePath, clone, detach, destroy, isAlive, addDisposer, hasEnv, getEnv, walk, type IModelReflectionData, type IModelReflectionPropertiesData, type IMaybeIType, type IMaybe, type IMaybeNull, type IOptionalIType, type OptionalDefaultValueOrFunction, type ValidOptionalValue, type ValidOptionalValues, getMembers, getPropertyMembers, type TypeOfValue, cast, castToSnapshot, castToReferenceSnapshot, isType, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isReferenceType, isRefinementType, isUnionType, tryReference, isValidReference, type OnReferenceInvalidated, type OnReferenceInvalidatedEvent, type ReferenceOptions, type ReferenceOptionsGetSet, type ReferenceOptionsOnInvalidated, type ReferenceIdentifier, type ISnapshotProcessor, type ISnapshotProcessors, getNodeId, type IActionContext, getRunningActionContext, isActionContextChildOf, isActionContextThisOrChildOf, types, types as t, // We do this as a less ambiguous term for the traditional types module, which sometimes gets confused when discussing "types" in general
 toGeneratorFunction, toGenerator } from "./internal";

package/dist/internal.d.ts

@@ -10,6 +10,7 @@ export * from "./middlewares/createActionTrackingMiddleware2";
 export * from "./middlewares/on-action";
 export * from "./core/action";
 export * from "./core/actionContext";
+export * from "./core/type/errorFormatting";
 export * from "./core/type/type-checker";
 export * from "./core/node/identifier-cache";
 export * from "./core/node/create-node";

package/dist/mobx-state-tree.js

@@ -1542,6 +1542,12 @@ var ObjectNode = /** @class */ (function (_super) {
             writable: true,
             value: false
         });
+        Object.defineProperty(_this, "_endOfActionCallbacks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(_this, "_observableInstanceState", {
             enumerable: true,
             configurable: true,
@@ -1612,8 +1618,8 @@ var ObjectNode = /** @class */ (function (_super) {
                     id = childNode.value;
                 }
             }
-            if (typeof id !== "string" && typeof id !== "number") {
-                throw new MstError("Instance identifier '".concat(_this.identifierAttribute, "' for type '").concat(_this.type.name, "' must be a string or a number"));
+            if (typeof id !== "string" && typeof id !== "number" && typeof id !== "bigint") {
+                throw new MstError("Instance identifier '".concat(_this.identifierAttribute, "' for type '").concat(_this.type.name, "' must be a string, a number or a bigint"));
             }
             // normalize internal identifier to string
             _this.identifier = normalizeIdentifier(id);
@@ -1751,6 +1757,33 @@ var ObjectNode = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(ObjectNode.prototype, "enqueueEndOfAction", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (callback) {
+            var root = this.root;
+            if (!root._endOfActionCallbacks) {
+                root._endOfActionCallbacks = [];
+            }
+            root._endOfActionCallbacks.push(callback);
+        }
+    });
+    Object.defineProperty(ObjectNode.prototype, "flushEndOfActionCallbacks", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var root = this.root;
+            while (root._endOfActionCallbacks && root._endOfActionCallbacks.length > 0) {
+                var callbacks = root._endOfActionCallbacks;
+                root._endOfActionCallbacks = undefined;
+                callbacks.forEach(function (callback) {
+                    callback();
+                });
+            }
+        }
+    });
     Object.defineProperty(ObjectNode.prototype, "clearParent", {
         enumerable: false,
         configurable: true,
@@ -3232,9 +3265,10 @@ function runWithActionContext(context, fn) {
     var baseIsRunningAction = node._isRunningAction;
     node._isRunningAction = true;
     var previousContext = currentActionContext;
+    var isRootActionContext = !previousContext;
     currentActionContext = context;
     try {
-        return runMiddleWares(node, context, fn);
+        return runMiddleWares(node, context, fn, isRootActionContext);
     }
     finally {
         currentActionContext = previousContext;
@@ -3388,17 +3422,44 @@ var CollectedMiddlewares = /** @class */ (function () {
     });
     return CollectedMiddlewares;
 }());
-function runMiddleWares(node, baseCall, originalFn) {
+function runMiddleWares(node, baseCall, originalFn, isRootActionContext) {
+    function runInActionScope(call, fn) {
+        var execute = function () {
+            var result;
+            var error;
+            try {
+                result = fn.apply(null, call.args);
+            }
+            catch (e) {
+                error = e;
+            }
+            if (isRootActionContext || !call.parentActionEvent) {
+                try {
+                    node.root.flushEndOfActionCallbacks();
+                }
+                catch (flushError) {
+                    if (!error) {
+                        error = flushError;
+                    }
+                }
+            }
+            if (error) {
+                throw error;
+            }
+            return result;
+        };
+        return call.name ? mobx.action(call.name, execute)() : mobx.action(execute)();
+    }
     var middlewares = new CollectedMiddlewares(node, originalFn);
     // Short circuit
     if (middlewares.isEmpty)
-        return mobx.action(originalFn).apply(null, baseCall.args);
+        return runInActionScope(baseCall, originalFn);
     var result = null;
     function runNextMiddleware(call) {
         var middleware = middlewares.getNextMiddleware();
         var handler = middleware && middleware.handler;
         if (!handler) {
-            return mobx.action(originalFn).apply(null, call.args);
+            return runInActionScope(call, originalFn);
         }
         // skip hooks if asked to
         if (!middleware.includeHooks && Hook[call.name]) {
@@ -3434,6 +3495,9 @@ function runMiddleWares(node, baseCall, originalFn) {
                 throw new MstError("The next() and abort() callback within the middleware ".concat(handler.name, " for the action: \"").concat(call.name, "\" on the node: ").concat(node2.type.name, " were invoked."));
             }
         }
+        if (abortInvoked && (isRootActionContext || !call.parentActionEvent)) {
+            return runInActionScope(call, function () { return result; });
+        }
         return result;
     }
     return runNextMiddleware(baseCall);
@@ -3475,30 +3539,207 @@ function isActionContextThisOrChildOf(actionContext, parentOrThis) {
     return _isActionContextThisOrChildOf(actionContext, parentOrThis, true);
 }
 
-function safeStringify(value) {
+var defaultOptions = {
+    enabled: false,
+    indent: 2,
+    maxStringLength: 100,
+    maxArrayLength: 10,
+    maxPropertyCount: 30,
+    maxDepth: 5
+};
+var currentOptions = __assign({}, defaultOptions);
+/**
+ * Configures how snapshots/values and type shapes are formatted inside
+ * type-checking error messages. This is **opt-in**: by default MST keeps its
+ * original single-line error formatting, so enabling this does not change
+ * behavior for anyone who doesn't call it.
+ *
+ * The given options are merged over the current ones, so you can set only the
+ * fields you care about.
+ *
+ * @example
+ * // pretty-print large snapshots across multiple lines and truncate them
+ * setErrorFormatting({ enabled: true })
+ *
+ * @example
+ * // only bound the message size, without reflowing it onto multiple lines
+ * setErrorFormatting({ enabled: true, indent: 0 })
+ *
+ * @example
+ * // tweak the truncation limits
+ * setErrorFormatting({ enabled: true, maxArrayLength: 3, maxStringLength: 40 })
+ *
+ * @param options A partial set of {@link ErrorFormattingOptions} to apply.
+ */
+function setErrorFormatting(options) {
+    currentOptions = __assign(__assign({}, currentOptions), options);
+}
+/**
+ * Returns a copy of the current error formatting options (see
+ * {@link setErrorFormatting}). Useful for temporarily overriding and then
+ * restoring the configuration.
+ *
+ * @returns The current {@link ErrorFormattingOptions}.
+ */
+function getErrorFormatting() {
+    return __assign({}, currentOptions);
+}
+
+function safeStringify(value, indent) {
     try {
-        return JSON.stringify(value);
+        return JSON.stringify(value, null, indent);
     }
     catch (e) {
         // istanbul ignore next
         return "<Unserializable: ".concat(e, ">");
     }
 }
+function shortenPrintValue(valueInString) {
+    return valueInString.length < 280
+        ? valueInString
+        : "".concat(valueInString.substring(0, 272), "......").concat(valueInString.substring(valueInString.length - 8));
+}
+/**
+ * Returns a clone of `value` in which overly long strings are clipped and large
+ * arrays/objects (or values nested too deeply) are summarized, so the result is
+ * safe to print in an error message without flooding the screen.
+ */
+function truncateForDisplay(value, depth, options) {
+    if (typeof value === "string") {
+        return value.length > options.maxStringLength
+            ? "".concat(value.slice(0, options.maxStringLength), "\u2026 (").concat(value.length - options.maxStringLength, " more characters)")
+            : value;
+    }
+    if (Array.isArray(value)) {
+        if (depth >= options.maxDepth)
+            return "[…]";
+        var items = value
+            .slice(0, options.maxArrayLength)
+            .map(function (item) { return truncateForDisplay(item, depth + 1, options); });
+        if (value.length > options.maxArrayLength) {
+            items.push("\u2026 ".concat(value.length - options.maxArrayLength, " more items"));
+        }
+        return items;
+    }
+    if (isPlainObject(value)) {
+        if (depth >= options.maxDepth)
+            return "{…}";
+        var result_1 = {};
+        var keys = Object.keys(value);
+        keys.slice(0, options.maxPropertyCount).forEach(function (key) {
+            result_1[key] = truncateForDisplay(value[key], depth + 1, options);
+        });
+        if (keys.length > options.maxPropertyCount) {
+            result_1["…"] = "".concat(keys.length - options.maxPropertyCount, " more keys");
+        }
+        return result_1;
+    }
+    return value;
+}
 /**
  * @internal
  * @hidden
  */
 function prettyPrintValue(value) {
-    return typeof value === "function"
-        ? "<function".concat(value.name ? " " + value.name : "", ">")
-        : isStateTreeNode(value)
-            ? "<".concat(value, ">")
-            : "`".concat(safeStringify(value), "`");
+    if (typeof value === "function") {
+        return "<function".concat(value.name ? " " + value.name : "", ">");
+    }
+    if (isStateTreeNode(value)) {
+        return "<".concat(value, ">");
+    }
+    var options = getErrorFormatting();
+    if (!options.enabled) {
+        // Default behavior: serialize the value compactly on a single line.
+        // JSON.stringify returns `undefined` for values like `undefined` itself,
+        // which the template literal coerces back to a string.
+        return "`".concat(safeStringify(value), "`");
+    }
+    // Opt-in behavior: clip long strings, big arrays/objects and deep nesting, and
+    // (when indent > 0) pretty-print the result across multiple lines.
+    var truncated = truncateForDisplay(value, 0, options);
+    return "`".concat(safeStringify(truncated, options.indent || undefined), "`");
 }
-function shortenPrintValue(valueInString) {
-    return valueInString.length < 280
-        ? valueInString
-        : "".concat(valueInString.substring(0, 272), "......").concat(valueInString.substring(valueInString.length - 8));
+/**
+ * Re-indents a type description (as produced by `IType.describe()`) across
+ * multiple lines, by breaking after the `{`, `}` and `;` separators used in
+ * model shapes (while leaving union `|` and array `[]` parts inline).
+ * Characters inside string literals (e.g. literal types like `"a;b"`) are left
+ * untouched.
+ *
+ * `indentSize` is the number of spaces per nesting level; when it is `0` (or
+ * negative) the description is returned unchanged on a single line. As this runs
+ * while formatting an error that is already being thrown, it must never throw
+ * itself: any unexpected input falls back to the original, unformatted
+ * description.
+ *
+ * @internal
+ * @hidden
+ */
+function prettyPrintDescription(description, indentSize) {
+    if (indentSize <= 0) {
+        return description;
+    }
+    try {
+        var step_1 = " ".repeat(indentSize);
+        var result_2 = "";
+        var depth_1 = 0;
+        var stringDelimiter = null;
+        var escaped = false;
+        var newline = function () {
+            // drop any trailing spaces (e.g. the "{ " / "; " separators) before breaking,
+            // and never let a malformed (over-closed) shape produce a negative indent
+            result_2 = result_2.replace(/[ \t]+$/, "");
+            result_2 += "\n" + step_1.repeat(Math.max(0, depth_1));
+        };
+        for (var i = 0; i < description.length; i++) {
+            var char = description[i];
+            if (stringDelimiter) {
+                result_2 += char;
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === "\\") {
+                    escaped = true;
+                }
+                else if (char === stringDelimiter) {
+                    stringDelimiter = null;
+                }
+                continue;
+            }
+            switch (char) {
+                case '"':
+                case "'":
+                    stringDelimiter = char;
+                    result_2 += char;
+                    break;
+                case "{":
+                    depth_1++;
+                    result_2 += "{";
+                    newline();
+                    while (description[i + 1] === " ")
+                        i++;
+                    break;
+                case "}":
+                    depth_1--;
+                    newline();
+                    result_2 += "}";
+                    break;
+                case ";":
+                    result_2 += ";";
+                    newline();
+                    while (description[i + 1] === " ")
+                        i++;
+                    break;
+                default:
+                    result_2 += char;
+            }
+        }
+        return result_2;
+    }
+    catch (e) {
+        // istanbul ignore next - defensive: never let formatting hide the real error
+        return description;
+    }
 }
 function toErrorString(error) {
     var value = error.value;
@@ -3517,12 +3758,18 @@ function toErrorString(error) {
             ? "value"
             : "snapshot";
     var isSnapshotCompatible = type && isStateTreeNode(value) && type.is(getStateTreeNode(value).snapshot);
+    // When error formatting is enabled, the type shape is re-indented using the
+    // same indent setting as values; otherwise it's left on a single line.
+    var formatting = getErrorFormatting();
+    var describeType = function (t) {
+        return formatting.enabled ? prettyPrintDescription(t.describe(), formatting.indent) : t.describe();
+    };
     return ("".concat(pathPrefix).concat(currentTypename, " ").concat(prettyPrintValue(value), " is not assignable ").concat(type ? "to type: `".concat(type.name, "`") : "") +
         (error.message ? " (".concat(error.message, ")") : "") +
         (type
             ? isPrimitiveType(type) || isPrimitive(value)
                 ? "."
-                : ", expected an instance of `".concat(type.name, "` or a snapshot like `").concat(type.describe(), "` instead.") +
+                : ", expected an instance of `".concat(type.name, "` or a snapshot like `").concat(describeType(type), "` instead.") +
                     (isSnapshotCompatible
                         ? " (Note that a snapshot of the provided value is compatible with the targeted type)"
                         : "")
@@ -3585,7 +3832,14 @@ function validationErrorsToString(type, value, errors) {
     if (errors.length === 0) {
         return undefined;
     }
-    return ("Error while converting ".concat(shortenPrintValue(prettyPrintValue(value)), " to `").concat(type.name, "`:\n\n    ") + errors.map(toErrorString).join("\n    "));
+    // When formatting is disabled, keep the original behavior of capping the
+    // header value's length; when enabled, truncation already bounds its size.
+    var printedValue = prettyPrintValue(value);
+    var headerValue = getErrorFormatting().enabled
+        ? printedValue
+        : shortenPrintValue(printedValue);
+    return ("Error while converting ".concat(headerValue, " to `").concat(type.name, "`:\n\n    ") +
+        errors.map(toErrorString).join("\n    "));
 }
 
 var identifierCacheId = 0;
@@ -8133,7 +8387,7 @@ var BaseReferenceType = /** @class */ (function (_super) {
         value: function (value, context) {
             return isValidIdentifier(value)
                 ? typeCheckSuccess()
-                : typeCheckFailure(context, value, "Value is not a valid identifier, which is a string or a number");
+                : typeCheckFailure(context, value, "Value is not a valid identifier, which is a string, number or a bigint");
         }
     });
     Object.defineProperty(BaseReferenceType.prototype, "fireInvalidated", {
@@ -8222,6 +8476,23 @@ var BaseReferenceType = /** @class */ (function (_super) {
                     onRefTargetDestroyedHookDisposer();
                 }
             });
+            var scheduleRetryAfterReconciliation = function () {
+                var retry = function () {
+                    if (!storedRefNode.isAlive) {
+                        return;
+                    }
+                    if (_this.getSnapshot(storedRefNode) !== identifier) {
+                        return;
+                    }
+                    startWatching(false);
+                };
+                if (getCurrentActionContext()) {
+                    storedRefNode.root.enqueueEndOfAction(retry);
+                }
+                else {
+                    setImmediateWithFallback(retry);
+                }
+            };
             var startWatching = function (sync) {
                 // re-create hook in case the stored ref gets reattached
                 if (onRefTargetDestroyedHookDisposer) {
@@ -8239,12 +8510,13 @@ var BaseReferenceType = /** @class */ (function (_super) {
                         refTargetNodeExists = storedRefNode.root.identifierCache.has(_this.targetType, 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) {
+                        // if the tree is already attached we may still be in the middle of a reconcile/applySnapshot,
+                        // so wait until the current MST action finishes before deciding whether to invalidate or
+                        // attach a watcher to a target that appeared later in the same action.
+                        if (sync) {
+                            scheduleRetryAfterReconciliation();
+                        }
+                        else {
                             _this.fireInvalidated("invalidSnapshotReference", storedRefNode, identifier, null);
                         }
                     }
@@ -8594,7 +8866,7 @@ var IdentifierNumberType = /** @class */ (function (_super) {
  * 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.
+ * This type accepts as parameter the value type of the identifier field that can be either string, number or bigint.
  *
  * Example:
  * ```ts
@@ -8621,6 +8893,110 @@ var identifier = new IdentifierType();
  * @returns
  */
 var identifierNumber = new IdentifierNumberType();
+/**
+ * @internal
+ * @hidden
+ * IdentifierBigintType uses SimpleType<bigint | string | number, string, bigint> so snapshots serialize to string (JSON-safe).
+ */
+var IdentifierBigintType = /** @class */ (function (_super) {
+    __extends(IdentifierBigintType, _super);
+    function IdentifierBigintType() {
+        var _this = _super.call(this, "identifierBigint") || this;
+        Object.defineProperty(_this, "flags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: TypeFlags.Identifier
+        });
+        return _this;
+    }
+    Object.defineProperty(IdentifierBigintType.prototype, "createNewInstance", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (snapshot) {
+            if (typeof snapshot === "bigint")
+                return snapshot;
+            return BigInt(snapshot);
+        }
+    });
+    Object.defineProperty(IdentifierBigintType.prototype, "instantiate", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (parent, subpath, environment, initialValue) {
+            if (!parent || !(parent.type instanceof ModelType))
+                throw new MstError("Identifier types can only be instantiated as direct child of a model type");
+            return createScalarNode(this, parent, subpath, environment, initialValue);
+        }
+    });
+    Object.defineProperty(IdentifierBigintType.prototype, "reconcile", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (current, newValue, parent, subpath) {
+            var currentVal = current.storedValue;
+            var newVal = typeof newValue === "bigint" ? newValue : BigInt(newValue);
+            if (currentVal !== newVal)
+                throw new MstError("Tried to change identifier from '".concat(currentVal, "' to '").concat(newVal, "'. Changing identifiers is not allowed."));
+            current.setParent(parent, subpath);
+            return current;
+        }
+    });
+    Object.defineProperty(IdentifierBigintType.prototype, "isValidSnapshot", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (value, context) {
+            if (typeof value === "bigint") {
+                return typeCheckSuccess();
+            }
+            if (typeof value === "string" || typeof value === "number") {
+                try {
+                    // BigInt primitive constructor verifies whether the value is a valid integer
+                    BigInt(value);
+                    return typeCheckSuccess();
+                }
+                catch (e) {
+                    var errorMessage = e instanceof Error ? e.message : String(e);
+                    return typeCheckFailure(context, value, "Value is not a valid ".concat(this.describe(), ": ").concat(errorMessage));
+                }
+            }
+            return typeCheckFailure(context, value, "Value is not a valid ".concat(this.describe(), ", expected a bigint, a string or a number"));
+        }
+    });
+    Object.defineProperty(IdentifierBigintType.prototype, "getSnapshot", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (node) {
+            return String(node.storedValue);
+        }
+    });
+    Object.defineProperty(IdentifierBigintType.prototype, "describe", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return "identifierBigint";
+        }
+    });
+    return IdentifierBigintType;
+}(SimpleType));
+/**
+ * `types.identifierBigint` - Similar to `types.identifier`. Snapshots serialize to string (JSON-safe) and deserialize from string, number or bigint.
+ *
+ * Example:
+ * ```ts
+ *  const Todo = types.model("Todo", {
+ *      id: types.identifierBigint,
+ *      title: types.string
+ *  })
+ * ```
+ *
+ * @returns
+ */
+var identifierBigint = new IdentifierBigintType();
 /**
  * Returns if a given value represents an identifier type.
  *
@@ -8642,14 +9018,14 @@ function normalizeIdentifier(id) {
  * @hidden
  */
 function isValidIdentifier(id) {
-    return typeof id === "string" || typeof id === "number";
+    return typeof id === "string" || typeof id === "number" || typeof id === "bigint";
 }
 /**
  * @internal
  * @hidden
  */
 function assertIsValidIdentifier(id, argNumber) {
-    assertArg(id, isValidIdentifier, "string or number (identifier)", argNumber);
+    assertArg(id, isValidIdentifier, "string, number or bigint (identifier)", argNumber);
 }
 
 /**
@@ -8817,6 +9193,7 @@ var types = {
     frozen: frozen,
     identifier: identifier,
     identifierNumber: identifierNumber,
+    identifierBigint: identifierBigint,
     late: late,
     lazy: lazy,
     undefined: undefinedType,
@@ -8843,6 +9220,7 @@ exports.escapeJsonPath = escapeJsonPath;
 exports.flow = flow;
 exports.getChildType = getChildType;
 exports.getEnv = getEnv;
+exports.getErrorFormatting = getErrorFormatting;
 exports.getIdentifier = getIdentifier;
 exports.getLivelinessChecking = getLivelinessChecking;
 exports.getMembers = getMembers;
@@ -8890,6 +9268,7 @@ exports.recordActions = recordActions;
 exports.recordPatches = recordPatches;
 exports.resolveIdentifier = resolveIdentifier;
 exports.resolvePath = resolvePath;
+exports.setErrorFormatting = setErrorFormatting;
 exports.setLivelinessChecking = setLivelinessChecking;
 exports.setLivelynessChecking = setLivelynessChecking;
 exports.splitJsonPath = splitJsonPath;