mobx-state-tree 7.1.0 → 7.3.0

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

@@ -1542,6 +1542,12 @@
                 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 @@
                         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 @@
             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 @@
         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 @@
         });
         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 @@
                     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 @@
         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 @@
                 ? "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 @@
         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;
@@ -8111,7 +8365,7 @@
             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", {
@@ -8200,6 +8454,23 @@
                         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) {
@@ -8217,12 +8488,13 @@
                             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);
                             }
                         }
@@ -8572,7 +8844,7 @@
      * 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
@@ -8599,6 +8871,110 @@
      * @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.
      *
@@ -8620,14 +8996,14 @@
      * @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);
     }
 
     /**
@@ -8795,6 +9171,7 @@
         frozen: frozen,
         identifier: identifier,
         identifierNumber: identifierNumber,
+        identifierBigint: identifierBigint,
         late: late,
         lazy: lazy,
         undefined: undefinedType,
@@ -8821,6 +9198,7 @@
     exports.flow = flow;
     exports.getChildType = getChildType;
     exports.getEnv = getEnv;
+    exports.getErrorFormatting = getErrorFormatting;
     exports.getIdentifier = getIdentifier;
     exports.getLivelinessChecking = getLivelinessChecking;
     exports.getMembers = getMembers;
@@ -8868,6 +9246,7 @@
     exports.recordPatches = recordPatches;
     exports.resolveIdentifier = resolveIdentifier;
     exports.resolvePath = resolvePath;
+    exports.setErrorFormatting = setErrorFormatting;
     exports.setLivelinessChecking = setLivelinessChecking;
     exports.setLivelynessChecking = setLivelynessChecking;
     exports.splitJsonPath = splitJsonPath;