mobx-state-tree 7.1.0 → 7.3.0

package/dist/mobx-state-tree.module.js

@@ -1538,6 +1538,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,
@@ -1608,8 +1614,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);
@@ -1747,6 +1753,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,
@@ -3228,9 +3261,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;
@@ -3384,17 +3418,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 ? action(call.name, execute)() : action(execute)();
+    }
     var middlewares = new CollectedMiddlewares(node, originalFn);
     // Short circuit
     if (middlewares.isEmpty)
-        return 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 action(originalFn).apply(null, call.args);
+            return runInActionScope(call, originalFn);
         }
         // skip hooks if asked to
         if (!middleware.includeHooks && Hook[call.name]) {
@@ -3430,6 +3491,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);
@@ -3471,30 +3535,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;
@@ -3513,12 +3754,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)"
                         : "")
@@ -3581,7 +3828,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;
@@ -8129,7 +8383,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", {
@@ -8218,6 +8472,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) {
@@ -8235,12 +8506,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);
                         }
                     }
@@ -8590,7 +8862,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
@@ -8617,6 +8889,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.
  *
@@ -8638,14 +9014,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);
 }
 
 /**
@@ -8813,6 +9189,7 @@ var types = {
     frozen: frozen,
     identifier: identifier,
     identifierNumber: identifierNumber,
+    identifierBigint: identifierBigint,
     late: late,
     lazy: lazy,
     undefined: undefinedType,
@@ -8820,4 +9197,4 @@ var types = {
     snapshotProcessor: snapshotProcessor
 };
 
-export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware, createActionTrackingMiddleware2, decorate, destroy, detach, escapeJsonPath, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, hasEnv, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, process$1 as process, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setLivelinessChecking, setLivelynessChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };
+export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware, createActionTrackingMiddleware2, decorate, destroy, detach, escapeJsonPath, flow, getChildType, getEnv, getErrorFormatting, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, hasEnv, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, process$1 as process, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setErrorFormatting, setLivelinessChecking, setLivelynessChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };