@jbrowse/mobx-state-tree 6.6.1 → 6.7.0

package/dist/mobx-state-tree.mjs

@@ -466,7 +466,7 @@ function resolveIdentifier(type, target, identifier) {
     assertIsType(type, 1);
     assertIsStateTreeNode(target, 2);
     assertIsValidIdentifier(identifier, 3);
-    const node = getStateTreeNode(target).root.identifierCache.resolve(type, normalizeIdentifier(identifier));
+    const node = getStateTreeNode(target).root.identifierCache?.resolve(type, normalizeIdentifier(identifier));
     return node?.value;
 }
 /**
@@ -1209,7 +1209,7 @@ class ObjectNode extends BaseNode {
         // addNodeToCache no-ops without an identifier attribute, and reaching the
         // root to ask it is a walk up the whole parent chain
         if (this.identifierAttribute) {
-            const cache = parent ? parent.root.identifierCache : this.identifierCache;
+            const cache = parent ? parent.assertAttachable() : this.identifierCache;
             cache.addNodeToCache(this);
         }
     }
@@ -1220,8 +1220,11 @@ class ObjectNode extends BaseNode {
         }
     }
     createObservableInstance(fireHooks = true) {
+        const diedUncreated = this.state === NodeLifeCycle.DEAD &&
+            this._observableInstanceState ===
+                ObservableInstanceLifecycle.UNINITIALIZED;
         if (devMode()) {
-            if (this.state !== NodeLifeCycle.INITIALIZING) {
+            if (!diedUncreated && this.state !== NodeLifeCycle.INITIALIZING) {
                 // istanbul ignore next
                 throw fail("assertion failed: the creation of the observable instance must be done on the initializing phase");
             }
@@ -1274,6 +1277,9 @@ class ObjectNode extends BaseNode {
         // subscribes to never pays for a full-tree snapshot at creation. keepAlive
         // on _snapshotComputed preserves snapshot referential stability without it.
         this._childNodes = EMPTY_OBJECT;
+        if (diedUncreated) {
+            return;
+        }
         this.state = NodeLifeCycle.CREATED;
         if (fireHooks) {
             this.fireHook(Hook.afterCreate);
@@ -1328,6 +1334,19 @@ class ObjectNode extends BaseNode {
             child.notifyDetachOf(subject);
         }
     }
+    /**
+     * @internal
+     * @hidden
+     * A node that died inside a tree is its own root and has no identifier
+     * cache, so attaching it, or attaching anything to it, cannot work.
+     */
+    assertAttachable() {
+        const cache = this.root.identifierCache;
+        if (!cache) {
+            throw fail(`'${this}' is no longer part of a state tree, so it cannot be attached to one or have nodes attached to it.`);
+        }
+        return cache;
+    }
     setParent(newParent, subpath) {
         const parentChanged = newParent !== this.parent;
         const subpathChanged = subpath !== this.subpath;
@@ -1356,9 +1375,9 @@ class ObjectNode extends BaseNode {
             }
         }
         if (parentChanged) {
-            // attach to new parent
+            this.assertAttachable();
             this.environment = undefined; // will use root's
-            newParent.root.identifierCache.mergeCache(this);
+            newParent.assertAttachable().mergeCache(this);
             this.baseSetParent(newParent, subpath);
             this.fireHook(Hook.afterAttach);
         }
@@ -1554,13 +1573,33 @@ class ObjectNode extends BaseNode {
         addHiddenFinalProp(this.storedValue, "toJSON", toJSON);
     }
     aboutToDie() {
+        const wasUninitialized = this._observableInstanceState ===
+            ObservableInstanceLifecycle.UNINITIALIZED;
+        const children = this.getChildren();
+        if (wasUninitialized &&
+            (this.hasSnapshotPostProcessor ||
+                children.some(child => child instanceof ObjectNode &&
+                    child._observableInstanceState !==
+                        ObservableInstanceLifecycle.UNINITIALIZED))) {
+            this.createObservableInstanceIfNeeded();
+        }
+        for (const node of children) {
+            if (node.isAlive) {
+                node.aboutToDie();
+            }
+        }
         if (this._observableInstanceState ===
             ObservableInstanceLifecycle.UNINITIALIZED) {
             return;
         }
-        this.getChildren().forEach(node => {
-            node.aboutToDie();
-        });
+        if (wasUninitialized) {
+            const walked = new Set(children);
+            for (const node of this.getChildren()) {
+                if (node.isAlive && !walked.has(node)) {
+                    node.aboutToDie();
+                }
+            }
+        }
         // 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();
@@ -1857,12 +1896,16 @@ class ComplexType extends BaseType {
             current.setParent(parent, subpath);
             return current;
         }
+        const newNode = getStateTreeNodeSafe(newValue);
+        if (newNode) {
+            newNode.assertAttachable();
+            if (!current.isDetaching && newNode.isWithin(current)) {
+                throw fail(`Cannot assign ${newNode} to '${parent.path}/${subpath}': it is part of ${current}, which it would replace.`);
+            }
+        }
         // current node cannot be recycled in any way
         current.die(); // noop if detaching
-        // attempt to reuse the new one
-        if (isStateTreeNode(newValue) && this.isAssignableFrom(getType(newValue))) {
-            // newValue is a Node as well, move it here..
-            const newNode = getStateTreeNode(newValue);
+        if (newNode && this.isAssignableFrom(newNode.type)) {
             newNode.setParent(parent, subpath);
             return newNode;
         }