mobx-state-tree 7.2.0 → 7.3.0

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

@@ -3535,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;
@@ -3577,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)"
                         : "")
@@ -3645,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;
@@ -9007,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 };

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

@@ -3539,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;
@@ -3581,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)"
                             : "")
@@ -3649,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;
@@ -9008,6 +9198,7 @@
     exports.flow = flow;
     exports.getChildType = getChildType;
     exports.getEnv = getEnv;
+    exports.getErrorFormatting = getErrorFormatting;
     exports.getIdentifier = getIdentifier;
     exports.getLivelinessChecking = getLivelinessChecking;
     exports.getMembers = getMembers;
@@ -9055,6 +9246,7 @@
     exports.recordPatches = recordPatches;
     exports.resolveIdentifier = resolveIdentifier;
     exports.resolvePath = resolvePath;
+    exports.setErrorFormatting = setErrorFormatting;
     exports.setLivelinessChecking = setLivelinessChecking;
     exports.setLivelynessChecking = setLivelynessChecking;
     exports.splitJsonPath = splitJsonPath;