@jbrowse/mobx-state-tree 5.8.7 → 5.9.0

package/dist/mobx-state-tree.mjs

@@ -700,7 +700,6 @@ function walk(target, processor) {
     assertIsStateTreeNode(target, 1);
     assertIsFunction(processor, 2);
     const node = getStateTreeNode(target);
-    // tslint:disable-next-line:no_unused-variable
     node.getChildren().forEach(child => {
         if (isStateTreeNode(child.storedValue)) {
             walk(child.storedValue, processor);
@@ -2438,8 +2437,11 @@ function addMiddleware(target, handler, includeHooks = true) {
  */
 function decorate(handler, fn, includeHooks = true) {
     const middleware = { handler, includeHooks };
-    fn.$mst_middleware = fn.$mst_middleware || [];
-    fn.$mst_middleware.push(middleware);
+    const f = fn;
+    if (!f.$mst_middleware) {
+        f.$mst_middleware = [];
+    }
+    f.$mst_middleware.push(middleware);
     return fn;
 }
 class CollectedMiddlewares {
@@ -2448,8 +2450,9 @@ class CollectedMiddlewares {
     middlewares = [];
     constructor(node, fn) {
         // we just push middleware arrays into an array of arrays to avoid making copies
-        if (fn.$mst_middleware) {
-            this.middlewares.push(fn.$mst_middleware);
+        const mw = fn.$mst_middleware;
+        if (mw) {
+            this.middlewares.push(mw);
         }
         let n = node;
         // Find all middlewares. Optimization: cache this?
@@ -2491,7 +2494,7 @@ function runMiddleWares(node, baseCall, originalFn) {
             return action(originalFn)(...call.args);
         }
         // skip hooks if asked to
-        if (!middleware.includeHooks && Hook[call.name]) {
+        if (!middleware.includeHooks && call.name in Hook) {
             return runNextMiddleware(call);
         }
         let nextInvoked = false;
@@ -3169,17 +3172,15 @@ function freeze(value) {
  * Recursively freeze a value (if not in production)
  */
 function deepFreeze(value) {
-    if (!devMode()) {
-        return value;
-    }
-    freeze(value);
-    if (isPlainObject(value)) {
-        Object.keys(value).forEach(propKey => {
-            if (!isPrimitive(value[propKey]) &&
-                !Object.isFrozen(value[propKey])) {
-                deepFreeze(value[propKey]);
+    if (devMode()) {
+        freeze(value);
+        if (isPlainObject(value)) {
+            for (const v of Object.values(value)) {
+                if (!isPrimitive(v) && !Object.isFrozen(v)) {
+                    deepFreeze(v);
+                }
             }
-        });
+        }
     }
     return value;
 }
@@ -3545,8 +3546,9 @@ function createFlowSpawner(name, generator) {
             parentEvent: parentContext,
             parentActionEvent: parentActionContext
         };
+        const spawnerWithMw = spawner;
         function wrap(fn, type, arg) {
-            fn.$mst_middleware = spawner.$mst_middleware; // pick up any middleware attached to the flow
+            fn.$mst_middleware = spawnerWithMw.$mst_middleware; // pick up any middleware attached to the flow
             return runWithActionContext({
                 ...contextBase,
                 type,
@@ -3559,7 +3561,7 @@ function createFlowSpawner(name, generator) {
                 gen = generator(...initArgs);
                 onFulfilled(undefined); // kick off the flow
             };
-            init.$mst_middleware = spawner.$mst_middleware;
+            init.$mst_middleware = spawnerWithMw.$mst_middleware;
             runWithActionContext({
                 ...contextBase,
                 type: "flow_spawn",
@@ -4738,11 +4740,9 @@ class ModelType extends ComplexType {
             }
             // the goal of this is to make sure actions using "this" can call themselves,
             // while still allowing the middlewares to register them
-            const middlewares = action2.$mst_middleware; // make sure middlewares are not lost
             const boundAction = action2.bind(actions);
-            boundAction._isFlowAction =
-                action2._isFlowAction || false;
-            boundAction.$mst_middleware = middlewares;
+            boundAction._isFlowAction = action2._isFlowAction ?? false;
+            boundAction.$mst_middleware = action2.$mst_middleware;
             const actionInvoker = createActionInvoker(self, name, boundAction);
             actions[name] = actionInvoker;
             (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(self, name, actionInvoker);
@@ -4868,36 +4868,35 @@ class ModelType extends ComplexType {
         intercept(instance, this.willChange);
         observe(instance, this.didChange);
     }
-    willChange(chg) {
-        // TODO: mobx typings don't seem to take into account that newValue can be set even when removing a prop
-        const change = chg;
+    willChange(change) {
         const node = getStateTreeNode(change.object);
         const subpath = change.name;
         node.assertWritable({ subpath });
-        const childType = node.type.properties[subpath];
-        // only properties are typed, state are stored as-is references
-        if (childType) {
-            typecheckInternal(childType, change.newValue);
-            change.newValue = childType.reconcile(node.getChildNode(subpath), change.newValue, node, subpath);
+        // MST's removeChild sets the property to undefined rather than deleting it,
+        // so mobx only ever delivers "update"/"add" changes here, never "remove".
+        if (change.type !== "remove") {
+            const childType = node.type.properties[subpath];
+            // only properties are typed, state are stored as-is references
+            if (childType) {
+                typecheckInternal(childType, change.newValue);
+                change.newValue = childType.reconcile(node.getChildNode(subpath), change.newValue, node, subpath);
+            }
         }
         return change;
     }
-    didChange(chg) {
-        // TODO: mobx typings don't seem to take into account that newValue can be set even when removing a prop
-        const change = chg;
+    didChange(change) {
         const childNode = getStateTreeNode(change.object);
         const childType = childNode.type.properties[change.name];
-        if (!childType) {
-            // don't emit patches for volatile state
-            return;
+        // skip volatile state (no childType) and never-actually-occurring "remove" changes
+        if (childType && change.type !== "remove") {
+            const oldChildValue = change.type === "update" ? change.oldValue.snapshot : undefined;
+            childNode.emitPatch({
+                op: "replace",
+                path: escapeJsonPath(change.name),
+                value: change.newValue.snapshot,
+                oldValue: oldChildValue
+            }, childNode);
         }
-        const oldChildValue = change.oldValue ? change.oldValue.snapshot : undefined;
-        childNode.emitPatch({
-            op: "replace",
-            path: escapeJsonPath(change.name),
-            value: change.newValue.snapshot,
-            oldValue: oldChildValue
-        }, childNode);
     }
     getChildren(node) {
         const res = [];
@@ -5072,7 +5071,6 @@ class CoreType extends SimpleType {
         this.flags = flags;
         this.checker = checker;
         this.initializer = initializer;
-        this.flags = flags;
     }
     describe() {
         return this.name;
@@ -5103,7 +5101,6 @@ class CoreType extends SimpleType {
  * })
  * ```
  */
-// tslint:disable-next-line:variable-name
 const string = new CoreType("string", TypeFlags.String, v => typeof v === "string");
 /**
  * `types.number` - Creates a type that can only contain a numeric value.
@@ -5117,7 +5114,6 @@ const string = new CoreType("string", TypeFlags.String, v => typeof v === "strin
  * })
  * ```
  */
-// tslint:disable-next-line:variable-name
 const number = new CoreType("number", TypeFlags.Number, v => typeof v === "number");
 /**
  * `types.integer` - Creates a type that can only contain an integer value.
@@ -5130,7 +5126,6 @@ const number = new CoreType("number", TypeFlags.Number, v => typeof v === "numbe
  * })
  * ```
  */
-// tslint:disable-next-line:variable-name
 const integer = new CoreType("integer", TypeFlags.Integer, v => isInteger(v));
 /**
  * `types.float` - Creates a type that can only contain an float value.
@@ -5143,7 +5138,6 @@ const integer = new CoreType("integer", TypeFlags.Integer, v => isInteger(v));
  * })
  * ```
  */
-// tslint:disable-next-line:variable-name
 const float = new CoreType("float", TypeFlags.Float, v => isFloat(v));
 /**
  * `types.finite` - Creates a type that can only contain an finite value.
@@ -5156,7 +5150,6 @@ const float = new CoreType("float", TypeFlags.Float, v => isFloat(v));
  * })
  * ```
  */
-// tslint:disable-next-line:variable-name
 const finite = new CoreType("finite", TypeFlags.Finite, v => isFinite(v));
 /**
  * `types.boolean` - Creates a type that can only contain a boolean value.
@@ -5170,7 +5163,6 @@ const finite = new CoreType("finite", TypeFlags.Finite, v => isFinite(v));
  * })
  * ```
  */
-// tslint:disable-next-line:variable-name
 const boolean = new CoreType("boolean", TypeFlags.Boolean, v => typeof v === "boolean");
 /**
  * `types.null` - The type of the value `null`