@jbrowse/mobx-state-tree 5.11.1 → 5.11.2

package/dist/mobx-state-tree.mjs

@@ -1116,6 +1116,21 @@ class ScalarNode extends BaseNode {
 ScalarNode.prototype.die = action(ScalarNode.prototype.die);
 
 let nextNodeId = 1;
+var ObservableInstanceLifecycle;
+(function (ObservableInstanceLifecycle) {
+    // the actual observable instance has not been created yet
+    ObservableInstanceLifecycle[ObservableInstanceLifecycle["UNINITIALIZED"] = 0] = "UNINITIALIZED";
+    // the actual observable instance is being created
+    ObservableInstanceLifecycle[ObservableInstanceLifecycle["CREATING"] = 1] = "CREATING";
+    // the actual observable instance has been created
+    ObservableInstanceLifecycle[ObservableInstanceLifecycle["CREATED"] = 2] = "CREATED";
+})(ObservableInstanceLifecycle || (ObservableInstanceLifecycle = {}));
+var InternalEvents;
+(function (InternalEvents) {
+    InternalEvents["Dispose"] = "dispose";
+    InternalEvents["Patch"] = "patch";
+    InternalEvents["Snapshot"] = "snapshot";
+})(InternalEvents || (InternalEvents = {}));
 const snapshotReactionOptions = {
     onError(e) {
         throw e;
@@ -1147,7 +1162,7 @@ class ObjectNode extends BaseNode {
     _autoUnbox = true; // unboxing is disabled when reading child nodes
     _isRunningAction = false; // only relevant for root
     _hasSnapshotReaction = false;
-    _observableInstanceState = 0 /* ObservableInstanceLifecycle.UNINITIALIZED */;
+    _observableInstanceState = ObservableInstanceLifecycle.UNINITIALIZED;
     _childNodes;
     _initialSnapshot;
     _cachedInitialSnapshot;
@@ -1192,7 +1207,7 @@ class ObjectNode extends BaseNode {
     }
     createObservableInstanceIfNeeded(fireHooks = true) {
         if (this._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             this.createObservableInstance(fireHooks);
         }
     }
@@ -1203,7 +1218,7 @@ class ObjectNode extends BaseNode {
                 throw fail("assertion failed: the creation of the observable instance must be done on the initializing phase");
             }
         }
-        this._observableInstanceState = 1 /* ObservableInstanceLifecycle.CREATING */;
+        this._observableInstanceState = ObservableInstanceLifecycle.CREATING;
         // make sure the parent chain is created as well
         // array with parent chain from parent to child
         const parentChain = [];
@@ -1213,7 +1228,7 @@ class ObjectNode extends BaseNode {
         // this is done to avoid traversing the whole tree to the root when using
         // the same reference again
         while (parent?._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             parentChain.unshift(parent);
             parent = parent.parent;
         }
@@ -1238,7 +1253,7 @@ class ObjectNode extends BaseNode {
         finally {
             this._isRunningAction = false;
         }
-        this._observableInstanceState = 2 /* ObservableInstanceLifecycle.CREATED */;
+        this._observableInstanceState = ObservableInstanceLifecycle.CREATED;
         this._snapshotComputed.trackAndCompute();
         if (this.isRoot) {
             this._addSnapshotReaction();
@@ -1352,7 +1367,7 @@ class ObjectNode extends BaseNode {
         if (!this.isAlive) {
             return this._snapshotUponDeath;
         }
-        return this._observableInstanceState === 2 /* ObservableInstanceLifecycle.CREATED */
+        return this._observableInstanceState === ObservableInstanceLifecycle.CREATED
             ? this._getActualSnapshot()
             : this._getCachedInitialSnapshot();
     }
@@ -1415,7 +1430,7 @@ class ObjectNode extends BaseNode {
         this._autoUnbox = false;
         try {
             return this._observableInstanceState ===
-                2 /* ObservableInstanceLifecycle.CREATED */
+                ObservableInstanceLifecycle.CREATED
                 ? this.type.getChildNode(this, subpath)
                 : this._childNodes[subpath];
         }
@@ -1428,7 +1443,7 @@ class ObjectNode extends BaseNode {
         this._autoUnbox = false;
         try {
             return this._observableInstanceState ===
-                2 /* ObservableInstanceLifecycle.CREATED */
+                ObservableInstanceLifecycle.CREATED
                 ? this.type.getChildren(this)
                 : convertChildNodesToArray(this._childNodes);
         }
@@ -1514,7 +1529,7 @@ class ObjectNode extends BaseNode {
     }
     aboutToDie() {
         if (this._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             return;
         }
         this.getChildren().forEach(node => {
@@ -1523,8 +1538,8 @@ class ObjectNode extends BaseNode {
         // beforeDestroy should run before the disposers since else we could end up in a situation where
         // a disposer added with addDisposer at this stage (beforeDestroy) is actually never released
         this.baseAboutToDie();
-        this._internalEventsEmit("dispose" /* InternalEvents.Dispose */);
-        this._internalEventsClear("dispose" /* InternalEvents.Dispose */);
+        this._internalEventsEmit(InternalEvents.Dispose);
+        this._internalEventsClear(InternalEvents.Dispose);
     }
     finalizeDeath() {
         // invariant: not called directly but from "die"
@@ -1540,42 +1555,42 @@ class ObjectNode extends BaseNode {
     }
     onSnapshot(onChange) {
         this._addSnapshotReaction();
-        return this._internalEventsRegister("snapshot" /* InternalEvents.Snapshot */, onChange);
+        return this._internalEventsRegister(InternalEvents.Snapshot, onChange);
     }
     emitSnapshot(snapshot) {
-        this._internalEventsEmit("snapshot" /* InternalEvents.Snapshot */, snapshot);
+        this._internalEventsEmit(InternalEvents.Snapshot, snapshot);
     }
     onPatch(handler) {
-        return this._internalEventsRegister("patch" /* InternalEvents.Patch */, handler);
+        return this._internalEventsRegister(InternalEvents.Patch, handler);
     }
     emitPatch(basePatch, source) {
-        if (this._internalEventsHasSubscribers("patch" /* InternalEvents.Patch */)) {
+        if (this._internalEventsHasSubscribers(InternalEvents.Patch)) {
             const localizedPatch = {
                 ...basePatch,
-                path: `${source.path.substr(this.path.length)}/${basePatch.path}` // calculate the relative path of the patch
+                path: `${source.path.slice(this.path.length)}/${basePatch.path}` // calculate the relative path of the patch
             };
             const [patch, reversePatch] = splitPatch(localizedPatch);
-            this._internalEventsEmit("patch" /* InternalEvents.Patch */, patch, reversePatch);
+            this._internalEventsEmit(InternalEvents.Patch, patch, reversePatch);
         }
         if (this.parent) {
             this.parent.emitPatch(basePatch, source);
         }
     }
     hasDisposer(disposer) {
-        return this._internalEventsHas("dispose" /* InternalEvents.Dispose */, disposer);
+        return this._internalEventsHas(InternalEvents.Dispose, disposer);
     }
     addDisposer(disposer) {
         if (!this.hasDisposer(disposer)) {
-            this._internalEventsRegister("dispose" /* InternalEvents.Dispose */, disposer, true);
+            this._internalEventsRegister(InternalEvents.Dispose, disposer, true);
             return;
         }
         throw fail("cannot add a disposer when it is already registered for execution");
     }
     removeDisposer(disposer) {
-        if (!this._internalEventsHas("dispose" /* InternalEvents.Dispose */, disposer)) {
+        if (!this._internalEventsHas(InternalEvents.Dispose, disposer)) {
             throw fail("cannot remove a disposer which was never registered for execution");
         }
-        this._internalEventsUnregister("dispose" /* InternalEvents.Dispose */, disposer);
+        this._internalEventsUnregister(InternalEvents.Dispose, disposer);
     }
     removeMiddleware(middleware) {
         if (this.middlewares) {
@@ -2565,22 +2580,47 @@ function isActionContextThisOrChildOf(actionContext, parentOrThis) {
 }
 
 const MAX_STRINGIFY_DEPTH = 3;
+const MAX_STRINGIFY_ARRAY_ITEMS = 10;
+const MAX_STRINGIFY_OBJECT_KEYS = 20;
+const MAX_STRINGIFY_STRING_LENGTH = 100;
+// Recursively cap depth, array length, object key count, and string length so a
+// huge offending snapshot degrades into readable, bounded context instead of a
+// wall of text that then gets sliced mid-structure. The depth cap also bounds
+// recursion on circular structures.
+function truncateForStringify(value, depth) {
+    if (typeof value === "string") {
+        return value.length > MAX_STRINGIFY_STRING_LENGTH
+            ? `${value.substring(0, MAX_STRINGIFY_STRING_LENGTH)}… (${value.length - MAX_STRINGIFY_STRING_LENGTH} more characters)`
+            : value;
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (depth >= MAX_STRINGIFY_DEPTH) {
+        return Array.isArray(value) ? "[…]" : "{…}";
+    }
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, MAX_STRINGIFY_ARRAY_ITEMS)
+            .map(item => truncateForStringify(item, depth + 1));
+        if (value.length > MAX_STRINGIFY_ARRAY_ITEMS) {
+            items.push(`… ${value.length - MAX_STRINGIFY_ARRAY_ITEMS} more items`);
+        }
+        return items;
+    }
+    const keys = Object.keys(value);
+    const result = {};
+    for (const key of keys.slice(0, MAX_STRINGIFY_OBJECT_KEYS)) {
+        result[key] = truncateForStringify(value[key], depth + 1);
+    }
+    if (keys.length > MAX_STRINGIFY_OBJECT_KEYS) {
+        result["…"] = `${keys.length - MAX_STRINGIFY_OBJECT_KEYS} more keys`;
+    }
+    return result;
+}
 function safeStringify(value) {
     try {
-        const ancestors = [];
-        return JSON.stringify(value, function (_key, val) {
-            if (val !== null && typeof val === "object") {
-                while (ancestors.length > 0 &&
-                    ancestors[ancestors.length - 1] !== this) {
-                    ancestors.pop();
-                }
-                if (ancestors.length >= MAX_STRINGIFY_DEPTH) {
-                    return Array.isArray(val) ? "[…]" : "{…}";
-                }
-                ancestors.push(val);
-            }
-            return val;
-        });
+        return JSON.stringify(truncateForStringify(value, 0));
     }
     catch (e) {
         // istanbul ignore next
@@ -3011,31 +3051,6 @@ function convertChildNodesToArray(childNodes) {
     return result;
 }
 
-// based on: https://github.com/mobxjs/mobx-utils/blob/master/src/async-action.ts
-/*
-    All contents of this file are deprecated.
-
-    The term `process` has been replaced with `flow` to avoid conflicts with the
-    global `process` object.
-
-    Refer to `flow.ts` for any further changes to this implementation.
-*/
-const DEPRECATION_MESSAGE = "See https://github.com/mobxjs/mobx-state-tree/issues/399 for more information. " +
-    "Note that the middleware event types starting with `process` now start with `flow`.";
-/**
- * @hidden
- *
- * @deprecated has been renamed to `flow()`.
- * See https://github.com/mobxjs/mobx-state-tree/issues/399 for more information.
- * Note that the middleware event types starting with `process` now start with `flow`.
- *
- * @returns {Promise}
- */
-function process$1(asyncAction) {
-    deprecated("process", `\`process()\` has been renamed to \`flow()\`. ${DEPRECATION_MESSAGE}`);
-    return flow(asyncAction);
-}
-
 const plainObjectString = Object.toString();
 /**
  * @internal
@@ -3326,25 +3341,6 @@ class EventHandlers {
         }
     }
 }
-/**
- * @internal
- * @hidden
- */
-const deprecated = function (id, message) {
-    // skip if running production
-    if (!devMode()) {
-        return;
-    }
-    // warn if hasn't been warned before
-    if (deprecated.ids && !deprecated.ids.hasOwnProperty(id)) {
-        warnError(`Deprecation warning: ${message}`);
-    }
-    // mark as warned to avoid duplicate warn message
-    if (deprecated.ids) {
-        deprecated.ids[id] = true;
-    }
-};
-deprecated.ids = {};
 /**
  * @internal
  * @hidden
@@ -4297,9 +4293,9 @@ class ArrayType extends ComplexType {
         return node.storedValue.slice();
     }
     getChildNode(node, key) {
-        const index = Number(key);
-        if (index < node.storedValue.length) {
-            return node.storedValue[index];
+        const child = node.storedValue[Number(key)];
+        if (child) {
+            return child;
         }
         throw fail(`Not a child: ${key}`);
     }
@@ -4466,7 +4462,7 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths
             // both are empty, end
             break;
         }
-        else if (!hasNewNode) {
+        else if (oldNode && !hasNewNode) {
             // new one does not exists
             nothingChanged = false;
             oldNodes.splice(i, 1);
@@ -7006,5 +7002,5 @@ const types = {
     resilient
 };
 
-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, getUnionSubtypes, 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, setDevMode, setLivelinessChecking, setLivelynessChecking, setTypeChecking, 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, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, getUnionSubtypes, 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, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setDevMode, setLivelinessChecking, setLivelynessChecking, setTypeChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };
 //# sourceMappingURL=mobx-state-tree.mjs.map