@jbrowse/mobx-state-tree 5.8.6 → 5.9.0

package/dist/index.d.ts

@@ -1113,10 +1113,11 @@ interface IMiddlewareEvent extends IActionContext {
     /** Id of all events, from root until current (excluding current) */
     readonly allParentIds: number[];
 }
-interface FunctionWithFlag extends Function {
+type FunctionWithFlag = ((...args: any[]) => any) & {
     _isMSTAction?: boolean;
     _isFlowAction?: boolean;
-}
+    $mst_middleware?: IMiddleware[];
+};
 /**
  * @internal
  * @hidden
@@ -1160,7 +1161,7 @@ declare function addMiddleware(target: IAnyStateTreeNode, handler: IMiddlewareHa
  * @param includeHooks
  * @returns The original function
  */
-declare function decorate<T extends Function>(handler: IMiddlewareHandler, fn: T, includeHooks?: boolean): T;
+declare function decorate<T extends (...args: any[]) => any>(handler: IMiddlewareHandler, fn: T, includeHooks?: boolean): T;
 
 interface IActionContext {
     /** Event name (action name for actions) */
@@ -1658,26 +1659,26 @@ type IsOptionalValue<C, TV, FV> = undefined extends C ? TV : FV;
 type DefinablePropsNames<T> = {
     [K in keyof T]: IsOptionalValue<T[K], never, K>;
 }[keyof T];
+declare const $emptyObject: unique symbol;
+type EmptyObject = {
+    [$emptyObject]?: never;
+};
 /** @hidden */
-declare const $nonEmptyObject: unique symbol;
-/** @hidden */
-interface NonEmptyObject {
-    [$nonEmptyObject]?: any;
-}
+type MaybeEmpty<T> = keyof T extends never ? EmptyObject : T;
 /** @hidden */
 type ExtractCFromProps<P extends ModelProperties> = {
     [k in keyof P]: P[k]["CreationType"];
 };
 /** @hidden */
-type ModelCreationType<PC> = {
+type ModelCreationType<PC> = MaybeEmpty<{
     [P in DefinablePropsNames<PC>]: PC[P];
-} & Partial<PC> & NonEmptyObject;
+}> & Partial<PC>;
 /** @hidden */
-type ModelCreationType2<P extends ModelProperties, CustomC> = keyof P extends never ? IStateTreeNode : _CustomOrOther<CustomC, ModelCreationType<ExtractCFromProps<P>>>;
+type ModelCreationType2<P extends ModelProperties, CustomC> = MaybeEmpty<_CustomOrOther<CustomC, ModelCreationType<ExtractCFromProps<P>>>>;
 /** @hidden */
-type ModelSnapshotType<P extends ModelProperties> = {
+type ModelSnapshotType<P extends ModelProperties> = MaybeEmpty<{
     [K in keyof P]: P[K]["SnapshotType"];
-} & NonEmptyObject;
+}>;
 /** @hidden */
 type ModelSnapshotType2<P extends ModelProperties, CustomS> = _CustomOrOther<CustomS, ModelSnapshotType<P>>;
 /**
@@ -1686,7 +1687,7 @@ type ModelSnapshotType2<P extends ModelProperties, CustomS> = _CustomOrOther<Cus
  */
 type ModelInstanceTypeProps<P extends ModelProperties> = {
     [K in keyof P]: P[K]["Type"];
-} & NonEmptyObject;
+};
 /**
  * @hidden
  * do not transform this to an interface or model instance type generated declarations will be longer

package/dist/mobx-state-tree.cjs

@@ -702,7 +702,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);
@@ -2440,8 +2439,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 {
@@ -2450,8 +2452,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?
@@ -2493,7 +2496,7 @@ function runMiddleWares(node, baseCall, originalFn) {
             return mobx.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;
@@ -3171,17 +3174,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;
 }
@@ -3547,8 +3548,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,
@@ -3561,7 +3563,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",
@@ -4740,11 +4742,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);
@@ -4870,36 +4870,35 @@ class ModelType extends ComplexType {
         mobx.intercept(instance, this.willChange);
         mobx.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 = [];
@@ -5074,7 +5073,6 @@ class CoreType extends SimpleType {
         this.flags = flags;
         this.checker = checker;
         this.initializer = initializer;
-        this.flags = flags;
     }
     describe() {
         return this.name;
@@ -5105,7 +5103,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.
@@ -5119,7 +5116,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.
@@ -5132,7 +5128,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.
@@ -5145,7 +5140,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.
@@ -5158,7 +5152,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.
@@ -5172,7 +5165,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`