@jbrowse/mobx-state-tree 5.11.1 → 5.11.2

package/README.md

@@ -16,6 +16,79 @@ documents only the additions and changes made in this fork.
   exported string-keyed brand interfaces (`$EmptyObjectBrand`, `$__mstStateTreeNodeType__`),
   fixing tsgo TS4058/TS4023 errors when MST types appear in exported function return types
 
+## Error message changes
+
+Validation and conversion errors have been reworked to stay readable on large state
+trees. Upstream MST could throw error messages hundreds of kilobytes long because it
+expanded every union member's full structure and stringified entire snapshots unbounded.
+This fork keeps the errors short while making them more diagnosable.
+
+### Bounded conversion errors
+
+`typecheck()` / instantiation errors no longer dump unbounded output:
+
+- Stringified snapshots are depth-bound (nested objects past 3 levels collapse to `…`)
+- Each printed value is capped in length
+- At most 10 individual errors are reported, with a `(… and N more errors)` suffix
+
+### Scoped discriminated-union errors
+
+Take a union of view types discriminated by a literal `type` property:
+
+```ts
+const LinearGenomeView = types.model("LinearGenomeView", {
+  type: types.literal("LinearGenomeView"),
+  height: types.number,
+  assembly: types.string
+})
+const DotplotView = types.model("DotplotView", {
+  type: types.literal("DotplotView"),
+  height: types.number
+})
+const AnyView = types.union(LinearGenomeView, DotplotView)
+```
+
+Upstream MST listed every member's full structure on any failure. A single mistyped field
+produced output like this — each member's entire schema expanded inline, repeated for every
+member, often hundreds of kilobytes on a real config union:
+
+```
+No matching type for union(LinearGenomeView | DotplotView)
+(snapshot `{"type":"LinearGenomeView","height":"tall","assembly":"hg38"}` is not assignable
+to type: `({ type: ("LinearGenomeView" | snapshot like `"LinearGenomeView"`); height: number;
+assembly: string } | { type: ("DotplotView" | snapshot like `"DotplotView"`); height: number })`,
+expected an instance of `LinearGenomeView` or a snapshot like `{ type: ("LinearGenomeView" |
+snapshot like `"LinearGenomeView"`); height: number; assembly: string }` instead. … )
+```
+
+Now the error is scoped to the single member whose literal `type` matches the snapshot's
+discriminator, and reports only the property-level reasons it failed.
+
+`AnyView.create({ type: "LinearGenomeView", height: "tall", assembly: "hg38" })` throws:
+
+```
+[mobx-state-tree] Error while converting `{"type":"LinearGenomeView","height":"tall","assembly":"hg38"}` to `(LinearGenomeView | DotplotView)`:
+
+    at path "/height" value `"tall"` is not assignable to type: `number` (Value is not a number).
+```
+
+And in production builds (where full type-checking is skipped) a missing required field on a
+recognized member still names the discriminator and the offending path —
+`AnyView.create({ type: "LinearGenomeView", height: 100 })` throws:
+
+```
+[mobx-state-tree] No matching type for union (LinearGenomeView | DotplotView) for snapshot with type "LinearGenomeView":
+    at path "/assembly" value `undefined` is not assignable to type: `string` (Value is not a string).
+```
+
+Instead of a wall of text covering every union member, you get the discriminator that was
+seen plus the property-level reasons that one intended member rejected the snapshot (wrong
+field type, missing required field, etc.). The scoping drills through wrapped members
+(`optional`, `refinement`, `snapshotProcessor`, `late`) to find the underlying model, so
+real-world members like an `optional(model)` config schema are still matched correctly.
+When two members declare the same `type` literal (ambiguous), it falls back to the short
+message rather than guessing.
+
 ## Added APIs
 
 ### `types.resilient`
@@ -28,12 +101,12 @@ crashing the entire state tree.
 const PluginWidget = types.resilient(
   KnownWidget,
   UnknownWidget,
-  (error, originalSnapshot) => ({ kind: "unknown", raw: originalSnapshot }),
+  (error, originalSnapshot) => ({ kind: "unknown", raw: originalSnapshot })
 )
 
 // Arrays of plugins stay alive even if one entry is unrecognized
 const Store = types.model({
-  widgets: types.array(PluginWidget),
+  widgets: types.array(PluginWidget)
 })
 ```
 
@@ -66,11 +139,11 @@ creating a model:
 
 ```ts
 const Settings = types.model({
-  theme: types.optional(types.string, "light"),
+  theme: types.optional(types.string, "light")
 })
 
-const s = Settings.create()   // theme is "light"
-getSnapshot(s)                // { theme: "light" }
+const s = Settings.create() // theme is "light"
+getSnapshot(s) // { theme: "light" }
 ```
 
 Even though `"light"` is just the default, it always appears in the snapshot. If you store
@@ -84,17 +157,17 @@ equals the default:
 
 ```ts
 const Settings = types.model({
-  theme: types.stripDefault(types.string, "light"),
+  theme: types.stripDefault(types.string, "light")
 })
 
 const s = Settings.create()
-getSnapshot(s)                // {}  ← key omitted because value equals default
+getSnapshot(s) // {}  ← key omitted because value equals default
 
 s.theme = "dark"
-getSnapshot(s)                // { theme: "dark" }
+getSnapshot(s) // { theme: "dark" }
 
 s.theme = "light"
-getSnapshot(s)                // {}  ← omitted again
+getSnapshot(s) // {}  ← omitted again
 ```
 
 #### Why this matters
@@ -132,7 +205,7 @@ ignored (all children share one element type).
 const Box = types.model({ x: types.number, y: types.number })
 const box = Box.create({ x: 1, y: 2 })
 
-getChildType(box, "x").name  // "number"
+getChildType(box, "x").name // "number"
 ```
 
 **`getUnionSubtypes(type)`** — given a `types.union` type, returns the array of its member
@@ -141,7 +214,7 @@ types. Useful when you need to enumerate what a union can hold.
 ```ts
 const Shape = types.union(Circle, Square, Triangle)
 
-getUnionSubtypes(Shape)  // [Circle, Square, Triangle]
+getUnionSubtypes(Shape) // [Circle, Square, Triangle]
 ```
 
 **`getDefaultInstanceOrSnapshot(optionalType)`** — returns the default value (or snapshot)
@@ -151,5 +224,5 @@ default without having to create a model instance.
 ```ts
 const t = types.optional(types.string, "hello")
 
-t.getDefaultInstanceOrSnapshot()  // "hello"
+t.getDefaultInstanceOrSnapshot() // "hello"
 ```

package/dist/index.d.ts

@@ -1284,52 +1284,6 @@ interface IAnyStateTreeNode extends STNValue<any, IAnyType> {
  */
 declare function isStateTreeNode<IT extends IAnyComplexType = IAnyComplexType>(value: any): value is STNValue<Instance<IT>, IT>;
 
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<R>(generator: () => IterableIterator<any>): () => Promise<R>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1>(generator: (a1: A1) => IterableIterator<any>): (a1: A1) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2>(generator: (a1: A1, a2: A2) => IterableIterator<any>): (a1: A1, a2: A2) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3>(generator: (a1: A1, a2: A2, a3: A3) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4>(generator: (a1: A1, a2: A2, a3: A3, a4: A4) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4, A5>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4, A5, A6>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4, A5, A6, A7>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7) => Promise<any>;
-/**
- * @deprecated has been renamed to `flow()`.
- * @hidden
- */
-declare function process<A1, A2, A3, A4, A5, A6, A7, A8>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8) => IterableIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8) => Promise<any>;
-
 /**
  * @hidden
  */
@@ -2185,5 +2139,5 @@ declare const types: {
     resilient: typeof 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, 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 };
 export type { $EmptyObjectBrand, CustomTypeOptions, IActionContext, IActionRecorder, IActionTrackingMiddleware2Call, IActionTrackingMiddleware2Hooks, IActionTrackingMiddlewareHooks, IAnyComplexType, IAnyModelType, IAnyStateTreeNode, IAnyType, IArrayType, IComplexType, IDisposer, IJsonPatch, IMSTArray, IMSTMap, IMapType, IMaybe, IMaybeIType, IMaybeNull, IMiddlewareEvent, IMiddlewareEventType, IMiddlewareHandler, IModelReflectionData, IModelReflectionPropertiesData, IModelType, IOptionalIType, IPatchRecorder, IReferenceType, IReversibleJsonPatch, ISerializedActionCall, ISimpleType, ISnapshotProcessor, ISnapshotProcessors, IStateTreeNode, IType, ITypeUnion, Instance, LivelinessMode, LivelynessMode, ModelActions, ModelCreationType, ModelCreationType2, ModelInstanceType, ModelInstanceTypeProps, ModelPrimitive, ModelProperties, ModelPropertiesDeclaration, ModelPropertiesDeclarationToProperties, ModelSnapshotType, ModelSnapshotType2, OnReferenceInvalidated, OnReferenceInvalidatedEvent, OptionalDefaultValueOrFunction, ReferenceIdentifier, ReferenceOptions, ReferenceOptionsGetSet, ReferenceOptionsOnInvalidated, SnapshotIn, SnapshotOrInstance, SnapshotOut, TypeOfValue, TypeOrStateTreeNodeToStateTreeNode, UnionOptions, UnionStringArray, ValidOptionalValue, ValidOptionalValues, _CustomCSProcessor, _CustomJoin, _CustomOrOther, _NotCustomized };

package/dist/mobx-state-tree.cjs

@@ -1118,6 +1118,21 @@ class ScalarNode extends BaseNode {
 ScalarNode.prototype.die = mobx.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;
@@ -1149,7 +1164,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;
@@ -1194,7 +1209,7 @@ class ObjectNode extends BaseNode {
     }
     createObservableInstanceIfNeeded(fireHooks = true) {
         if (this._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             this.createObservableInstance(fireHooks);
         }
     }
@@ -1205,7 +1220,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 = [];
@@ -1215,7 +1230,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;
         }
@@ -1240,7 +1255,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();
@@ -1354,7 +1369,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();
     }
@@ -1417,7 +1432,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];
         }
@@ -1430,7 +1445,7 @@ class ObjectNode extends BaseNode {
         this._autoUnbox = false;
         try {
             return this._observableInstanceState ===
-                2 /* ObservableInstanceLifecycle.CREATED */
+                ObservableInstanceLifecycle.CREATED
                 ? this.type.getChildren(this)
                 : convertChildNodesToArray(this._childNodes);
         }
@@ -1516,7 +1531,7 @@ class ObjectNode extends BaseNode {
     }
     aboutToDie() {
         if (this._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             return;
         }
         this.getChildren().forEach(node => {
@@ -1525,8 +1540,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"
@@ -1542,42 +1557,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) {
@@ -2567,22 +2582,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
@@ -3013,31 +3053,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
@@ -3328,25 +3343,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
@@ -4299,9 +4295,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}`);
     }
@@ -4468,7 +4464,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);
@@ -7068,7 +7064,6 @@ exports.joinJsonPath = joinJsonPath;
 exports.onAction = onAction;
 exports.onPatch = onPatch;
 exports.onSnapshot = onSnapshot;
-exports.process = process$1;
 exports.protect = protect;
 exports.recordActions = recordActions;
 exports.recordPatches = recordPatches;