@jbrowse/mobx-state-tree 5.10.7 → 5.11.0

package/dist/mobx-state-tree.cjs

@@ -980,7 +980,7 @@ class BaseNode {
         if (this._escapedSubpath === undefined) {
             this._escapedSubpath = !this._subpath ? "" : escapeJsonPath(this._subpath);
         }
-        return (this.parent.getEscapedPath(reportObserved) + "/" + this._escapedSubpath);
+        return `${this.parent.getEscapedPath(reportObserved)}/${this._escapedSubpath}`;
     }
     get isRoot() {
         return this.parent === null;
@@ -1214,9 +1214,8 @@ class ObjectNode extends BaseNode {
         // uninitialized parent
         // this is done to avoid traversing the whole tree to the root when using
         // the same reference again
-        while (parent &&
-            parent._observableInstanceState ===
-                0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+        while (parent?._observableInstanceState ===
+            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
             parentChain.unshift(parent);
             parent = parent.parent;
         }
@@ -1404,12 +1403,9 @@ class ObjectNode extends BaseNode {
             actionContext = actionContext.parentActionEvent;
         }
         let actionFullPath = "";
-        if (actionContext && actionContext.name != null) {
+        if (actionContext?.name != null) {
             // try to use the context, and if it not available use the node one
-            const actionPath = (actionContext &&
-                actionContext.context &&
-                getPath(actionContext.context)) ||
-                escapedPath;
+            const actionPath = (actionContext.context && getPath(actionContext.context)) || escapedPath;
             actionFullPath = `${actionPath}.${actionContext.name}()`;
         }
         return `You are trying to read or write to an object that is no longer part of a state tree. (Object type: '${this.type.name}', Path upon death: '${escapedPath}', Subpath: '${subpath}', Action: '${actionFullPath}'). Either detach nodes first, or don't use objects after removing / replacing them in the tree.`;
@@ -1556,9 +1552,10 @@ class ObjectNode extends BaseNode {
     }
     emitPatch(basePatch, source) {
         if (this._internalEventsHasSubscribers("patch" /* InternalEvents.Patch */)) {
-            const localizedPatch = extend({}, basePatch, {
-                path: source.path.substr(this.path.length) + "/" + basePatch.path // calculate the relative path of the patch
-            });
+            const localizedPatch = {
+                ...basePatch,
+                path: `${source.path.substr(this.path.length)}/${basePatch.path}` // calculate the relative path of the patch
+            };
             const [patch, reversePatch] = splitPatch(localizedPatch);
             this._internalEventsEmit("patch" /* InternalEvents.Patch */, patch, reversePatch);
         }
@@ -1887,7 +1884,7 @@ class SimpleType extends BaseType {
  * @returns `true` if the value is a type.
  */
 function isType(value) {
-    return typeof value === "object" && value && value.isType === true;
+    return typeof value === "object" && value?.isType === true;
 }
 /**
  * @internal
@@ -2039,8 +2036,8 @@ function createActionTrackingMiddleware2(middlewareHooks) {
             const newCall = {
                 ...call,
                 // make a shallow copy of the parent action env
-                env: parentRunningAction && parentRunningAction.call.env,
-                parentCall: parentRunningAction && parentRunningAction.call
+                env: parentRunningAction?.call.env,
+                parentCall: parentRunningAction?.call
             };
             const passesFilter = !middlewareHooks.filter || middlewareHooks.filter(newCall);
             const hooks = passesFilter ? middlewareHooks : undefined;
@@ -2121,8 +2118,7 @@ function serializeArgument(node, actionName, index, arg) {
         return serializeTheUnserializable(`[function]`);
     }
     if (typeof arg === "object" && !isPlainObject(arg) && !isArray(arg)) {
-        return serializeTheUnserializable(`[object ${(arg && arg.constructor && arg.constructor.name) ||
-            "Complex Object"}]`);
+        return serializeTheUnserializable(`[object ${arg?.constructor?.name || "Complex Object"}]`);
     }
     try {
         // Check if serializable, cycle free etc...
@@ -2131,7 +2127,7 @@ function serializeArgument(node, actionName, index, arg) {
         return arg;
     }
     catch (e) {
-        return serializeTheUnserializable("" + e);
+        return serializeTheUnserializable(`${e}`);
     }
 }
 function deserializeArgument(adm, value) {
@@ -2491,7 +2487,7 @@ function runMiddleWares(node, baseCall, originalFn) {
     let result = null;
     function runNextMiddleware(call) {
         const middleware = middlewares.getNextMiddleware();
-        const handler = middleware && middleware.handler;
+        const handler = middleware?.handler;
         if (!handler) {
             return mobx.action(originalFn)(...call.args);
         }
@@ -2599,7 +2595,7 @@ function safeStringify(value) {
  */
 function prettyPrintValue(value) {
     return typeof value === "function"
-        ? `<function${value.name ? " " + value.name : ""}>`
+        ? `<function${value.name ? ` ${value.name}` : ""}>`
         : isStateTreeNode(value)
             ? `<${value}>`
             : `\`${safeStringify(value)}\``;
@@ -2623,16 +2619,13 @@ function toErrorString(error) {
             ? "value"
             : "snapshot";
     const isSnapshotCompatible = type && isStateTreeNode(value) && type.is(getStateTreeNode(value).snapshot);
-    return (`${pathPrefix}${currentTypename} ${shortenPrintValue(prettyPrintValue(value))} is not assignable ${type ? `to type: \`${type.name}\`` : ``}` +
-        (error.message ? ` (${error.message})` : "") +
-        (type
-            ? isPrimitiveType(type) || isPrimitive(value)
-                ? `.`
-                : `, expected an instance of \`${type.name}\` or a snapshot like \`${shortenPrintValue(type.describe())}\` instead.` +
-                    (isSnapshotCompatible
-                        ? " (Note that a snapshot of the provided value is compatible with the targeted type)"
-                        : "")
-            : `.`));
+    return `${pathPrefix}${currentTypename} ${shortenPrintValue(prettyPrintValue(value))} is not assignable ${type ? `to type: \`${type.name}\`` : ``}${error.message ? ` (${error.message})` : ""}${type
+        ? isPrimitiveType(type) || isPrimitive(value)
+            ? `.`
+            : `, expected an instance of \`${type.name}\` or a snapshot like \`${shortenPrintValue(type.describe())}\` instead.${isSnapshotCompatible
+                ? " (Note that a snapshot of the provided value is compatible with the targeted type)"
+                : ""}`
+        : `.`}`;
 }
 /**
  * @internal
@@ -2721,7 +2714,7 @@ function validationErrorsToString(type, value, errors) {
     if (errors.length === 0) {
         return undefined;
     }
-    return (`Error while converting ${shortenPrintValue(prettyPrintValue(value))} to \`${type.name}\`:\n\n    ` + formatValidationErrorLines(errors).join("\n    "));
+    return `Error while converting ${shortenPrintValue(prettyPrintValue(value))} to \`${type.name}\`:\n\n    ${formatValidationErrorLines(errors).join("\n    ")}`;
 }
 
 let identifierCacheId = 0;
@@ -2753,7 +2746,7 @@ class IdentifierCache {
                 this.cache.set(identifier, mobx.observable.array([], mobxShallow));
             }
             const set = this.cache.get(identifier);
-            if (set.indexOf(node) !== -1) {
+            if (set.includes(node)) {
                 throw fail(`Already registered`);
             }
             set.push(node);
@@ -2786,12 +2779,12 @@ class IdentifierCache {
         // The slash is added here so we only match children of the splitNode. In version 5.1.8 and
         // earlier there was no trailing slash, so non children that started with the same path string
         // were being matched incorrectly.
-        const basePath = splitNode.path + "/";
+        const basePath = `${splitNode.path}/`;
         mobx.entries(this.cache).forEach(([id, nodes]) => {
             let modified = false;
             for (let i = nodes.length - 1; i >= 0; i--) {
                 const node = nodes[i];
-                if (node === splitNode || node.path.indexOf(basePath) === 0) {
+                if (node === splitNode || node.path.startsWith(basePath)) {
                     newCache.addNodeToCache(node, false); // no need to update lastUpdated since it is a whole new cache
                     nodes.splice(i, 1);
                     // remove empty sets from cache
@@ -2889,7 +2882,7 @@ var NodeLifeCycle;
  * @returns true if the value is a state tree node.
  */
 function isStateTreeNode(value) {
-    return !!(value && value.$treenode);
+    return !!value?.$treenode;
 }
 /**
  * @internal
@@ -2914,7 +2907,7 @@ function getStateTreeNode(value) {
  * @hidden
  */
 function getStateTreeNodeSafe(value) {
-    return (value && value.$treenode) || null;
+    return value?.$treenode || null;
 }
 /**
  * @internal
@@ -3041,7 +3034,7 @@ const DEPRECATION_MESSAGE = "See https://github.com/mobxjs/mobx-state-tree/issue
  * @returns {Promise}
  */
 function process$1(asyncAction) {
-    deprecated("process", "`process()` has been renamed to `flow()`. " + DEPRECATION_MESSAGE);
+    deprecated("process", `\`process()\` has been renamed to \`flow()\`. ${DEPRECATION_MESSAGE}`);
     return flow(asyncAction);
 }
 
@@ -3069,7 +3062,7 @@ Object.freeze(mobxShallow);
  * @hidden
  */
 function fail(message = "Illegal state") {
-    return new Error("[mobx-state-tree] " + message);
+    return new Error(`[mobx-state-tree] ${message}`);
 }
 /**
  * @internal
@@ -3117,19 +3110,6 @@ function asArray(val) {
     }
     return [val];
 }
-/**
- * @internal
- * @hidden
- */
-function extend(a, ...b) {
-    for (let i = 0; i < b.length; i++) {
-        const current = b[i];
-        for (const key in current) {
-            a[key] = current[key];
-        }
-    }
-    return a;
-}
 /**
  * @internal
  * @hidden
@@ -3263,7 +3243,7 @@ class EventHandler {
         };
     }
     has(fn) {
-        return this.handlers.indexOf(fn) >= 0;
+        return this.handlers.includes(fn);
     }
     unregister(fn) {
         if (this.emitting) {
@@ -3312,8 +3292,7 @@ class EventHandler {
 class EventHandlers {
     eventHandlers;
     hasSubscribers(event) {
-        const handler = this.eventHandlers && this.eventHandlers[event];
-        return !!handler && handler.hasSubscribers;
+        return this.eventHandlers?.[event]?.hasSubscribers ?? false;
     }
     register(event, fn, atTheBeginning = false) {
         if (!this.eventHandlers) {
@@ -3326,11 +3305,10 @@ class EventHandlers {
         return handler.register(fn, atTheBeginning);
     }
     has(event, fn) {
-        const handler = this.eventHandlers && this.eventHandlers[event];
-        return !!handler && handler.has(fn);
+        return this.eventHandlers?.[event]?.has(fn) ?? false;
     }
     unregister(event, fn) {
-        const handler = this.eventHandlers && this.eventHandlers[event];
+        const handler = this.eventHandlers?.[event];
         if (handler) {
             handler.unregister(fn);
         }
@@ -3344,19 +3322,12 @@ class EventHandlers {
         this.eventHandlers = undefined;
     }
     emit(event, ...args) {
-        const handler = this.eventHandlers && this.eventHandlers[event];
+        const handler = this.eventHandlers?.[event];
         if (handler) {
             handler.emit(...args);
         }
     }
 }
-/**
- * @internal
- * @hidden
- */
-function stringStartsWith(str, beginning) {
-    return str.indexOf(beginning) === 0;
-}
 /**
  * @internal
  * @hidden
@@ -3368,7 +3339,7 @@ const deprecated = function (id, message) {
     }
     // warn if hasn't been warned before
     if (deprecated.ids && !deprecated.ids.hasOwnProperty(id)) {
-        warnError("Deprecation warning: " + message);
+        warnError(`Deprecation warning: ${message}`);
     }
     // mark as warned to avoid duplicate warn message
     if (deprecated.ids) {
@@ -3383,15 +3354,27 @@ deprecated.ids = {};
 function warnError(msg) {
     console.warn(new Error(`[mobx-state-tree] ${msg}`));
 }
+let _typeChecking;
+/**
+ * Forces full run-time type-checking on or off, overriding the dev-mode and
+ * `ENABLE_TYPE_CHECK` env-var defaults. Pass `true` to get better error messages
+ * in production builds without relying on an environment variable, `false` to
+ * force it off, or `undefined` to restore the default behavior.
+ */
+function setTypeChecking(enabled) {
+    _typeChecking = enabled;
+}
 /**
  * @internal
  * @hidden
  */
 function isTypeCheckingEnabled() {
-    return (devMode() ||
-        (typeof process !== "undefined" &&
-            process.env &&
-            process.env.ENABLE_TYPE_CHECK === "true"));
+    // an explicit setTypeChecking() override (incl. `false`) wins over the
+    // dev-mode / env-var default, hence ?? rather than ||
+    return (_typeChecking ??
+        (devMode() ||
+            (typeof process !== "undefined" &&
+                process.env?.ENABLE_TYPE_CHECK === "true")));
 }
 let _devMode = process.env.NODE_ENV !== "production";
 /**
@@ -3625,7 +3608,7 @@ function createFlowSpawner(name, generator) {
                 // TODO: support more type of values? See https://github.com/tj/co/blob/249bbdc72da24ae44076afd716349d2089b31c4c/index.js#L100
                 if (!ret.value || typeof ret.value.then !== "function") {
                     // istanbul ignore next
-                    throw fail("Only promises can be yielded to `async`, got: " + ret);
+                    throw fail(`Only promises can be yielded to \`async\`, got: ${ret}`);
                 }
                 return ret.value.then(onFulfilled, onRejected);
             }
@@ -3682,22 +3665,13 @@ function invertPatch(patch) {
             };
     }
 }
-/**
- * Simple simple check to check it is a number.
- */
-function isNumber(x) {
-    return typeof x === "number";
-}
 /**
  * Escape slashes and backslashes.
  *
  * http://tools.ietf.org/html/rfc6901
  */
 function escapeJsonPath(path) {
-    if (isNumber(path) === true) {
-        return "" + path;
-    }
-    if (path.indexOf("/") === -1 && path.indexOf("~") === -1) {
+    if (!path.includes("/") && !path.includes("~")) {
         return path;
     }
     return path.replace(/~/g, "~0").replace(/\//g, "~1");
@@ -3726,7 +3700,7 @@ function joinJsonPath(path) {
     }
     else {
         // absolute
-        return "/" + getPathStr(path);
+        return `/${getPathStr(path)}`;
     }
 }
 /**
@@ -3741,9 +3715,9 @@ function splitJsonPath(path) {
     const valid = path === "" ||
         path === "." ||
         path === ".." ||
-        stringStartsWith(path, "/") ||
-        stringStartsWith(path, "./") ||
-        stringStartsWith(path, "../");
+        path.startsWith("/") ||
+        path.startsWith("./") ||
+        path.startsWith("../");
     if (!valid) {
         throw fail(`a json path must be either rooted, empty or relative, but got '${path}'`);
     }
@@ -3951,16 +3925,16 @@ class MSTMap extends mobx.ObservableMap {
     }
     get(key) {
         // maybe this is over-enthousiastic? normalize numeric keys to strings
-        return super.get("" + key);
+        return super.get(`${key}`);
     }
     has(key) {
-        return super.has("" + key);
+        return super.has(`${key}`);
     }
     delete(key) {
-        return super.delete("" + key);
+        return super.delete(`${key}`);
     }
     set(key, value) {
-        return super.set("" + key, value);
+        return super.set(`${key}`, value);
     }
     put(value) {
         if (!value) {
@@ -4085,9 +4059,9 @@ class MapType extends ComplexType {
         return mobx.values(node.storedValue);
     }
     getChildNode(node, key) {
-        const childNode = node.storedValue.get("" + key);
+        const childNode = node.storedValue.get(`${key}`);
         if (!childNode) {
-            throw fail("Not a child " + key);
+            throw fail(`Not a child ${key}`);
         }
         return childNode;
     }
@@ -4195,7 +4169,7 @@ class MapType extends ComplexType {
             // Don't use target.replace, as it will throw away all existing items first
             for (const key in snapshot) {
                 target.set(key, snapshot[key]);
-                currentKeys["" + key] = true;
+                currentKeys[`${key}`] = true;
             }
         }
         Object.keys(currentKeys).forEach(key => {
@@ -4295,7 +4269,7 @@ class ArrayType extends ComplexType {
         const subType = objNode.type._subType;
         const result = {};
         snapshot.forEach((item, index) => {
-            const subpath = "" + index;
+            const subpath = `${index}`;
             result[subpath] = subType.instantiate(objNode, subpath, undefined, item);
         });
         return result;
@@ -4329,11 +4303,11 @@ class ArrayType extends ComplexType {
         if (index < node.storedValue.length) {
             return node.storedValue[index];
         }
-        throw fail("Not a child: " + key);
+        throw fail(`Not a child: ${key}`);
     }
     willChange(change) {
         const node = getStateTreeNode(change.object);
-        node.assertWritable({ subpath: "" + change.index });
+        node.assertWritable({ subpath: `${change.index}` });
         const subType = node.type._subType;
         const childNodes = node.getChildren();
         switch (change.type) {
@@ -4359,7 +4333,7 @@ class ArrayType extends ComplexType {
                     change.added = addedNodes;
                     // update paths of remaining items
                     for (let i = index + removedCount; i < childNodes.length; i++) {
-                        childNodes[i].setParent(node, "" + (i + added.length - removedCount));
+                        childNodes[i].setParent(node, `${i + added.length - removedCount}`);
                     }
                 }
                 break;
@@ -4382,7 +4356,7 @@ class ArrayType extends ComplexType {
             case "update":
                 return void node.emitPatch({
                     op: "replace",
-                    path: "" + change.index,
+                    path: `${change.index}`,
                     value: change.newValue.snapshot,
                     oldValue: change.oldValue ? change.oldValue.snapshot : undefined
                 }, node);
@@ -4390,15 +4364,15 @@ class ArrayType extends ComplexType {
                 for (let i = change.removedCount - 1; i >= 0; i--) {
                     node.emitPatch({
                         op: "remove",
-                        path: "" + (change.index + i),
+                        path: `${change.index + i}`,
                         oldValue: change.removed[i].snapshot
                     }, node);
                 }
                 for (let i = 0; i < change.addedCount; i++) {
                     node.emitPatch({
                         op: "add",
-                        path: "" + (change.index + i),
-                        value: node.getChildNode("" + (change.index + i)).snapshot,
+                        path: `${change.index + i}`,
+                        value: node.getChildNode(`${change.index + i}`).snapshot,
                         oldValue: undefined
                     }, node);
                 }
@@ -4433,7 +4407,7 @@ class ArrayType extends ComplexType {
             return typeCheckFailure(context, value, "Value is not an array");
         }
         for (let i = 0; i < value.length; i++) {
-            getContextForPath(context, "" + i, this._subType);
+            getContextForPath(context, `${i}`, this._subType);
             const errors = this._subType.validate(value[i], context);
             popContext(context);
             if (errors.length > 0) {
@@ -4484,7 +4458,7 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths
         const hasNewNode = i <= newValues.length - 1;
         const oldNode = oldNodes[i];
         let newValue = hasNewNode ? newValues[i] : undefined;
-        const newPath = "" + newPaths[i];
+        const newPath = `${newPaths[i]}`;
         // for some reason, instead of newValue we got a node, fallback to the storedValue
         // TODO: https://github.com/mobxjs/mobx-state-tree/issues/340#issuecomment-325581681
         if (isNode(newValue)) {
@@ -4920,18 +4894,18 @@ class ModelType extends ComplexType {
     }
     getChildNode(node, key) {
         if (!(key in this.properties)) {
-            throw fail("Not a value property: " + key);
+            throw fail(`Not a value property: ${key}`);
         }
         const adm = mobx._getAdministration(node.storedValue, key);
         const childNode = adm.raw?.();
         if (!childNode) {
-            throw fail("Node not available for property " + key);
+            throw fail(`Node not available for property ${key}`);
         }
         return childNode;
     }
     getSnapshot(node, applyPostProcess = true) {
         const res = {};
-        this.forAllProps((name, _type) => {
+        this.forAllProps((name, type) => {
             try {
                 // TODO: FIXME, make sure the observable ref is used!
                 const atom = mobx.getAtom(node.storedValue, name);
@@ -4940,7 +4914,11 @@ class ModelType extends ComplexType {
             catch (_e) {
                 throw fail(`${name} property is declared twice`);
             }
-            res[name] = this.getChildNode(node, name).snapshot;
+            const snapshot = this.getChildNode(node, name).snapshot;
+            // strip-default optionals omit their key when equal to the default
+            if (!shouldStripChildFromSnapshot(type, snapshot)) {
+                res[name] = snapshot;
+            }
         });
         if (applyPostProcess) {
             return this.applySnapshotPostProcessor(res);
@@ -4950,7 +4928,13 @@ class ModelType extends ComplexType {
     processInitialSnapshot(childNodes) {
         const processed = {};
         Object.keys(childNodes).forEach(key => {
-            processed[key] = childNodes[key].getSnapshot();
+            const snapshot = childNodes[key].getSnapshot();
+            // strip-default optionals omit their key when equal to the default; this
+            // mirrors getSnapshot for nodes serialized before they become observable
+            // instances (e.g. array/map children that were never accessed)
+            if (!shouldStripChildFromSnapshot(this.properties[key], snapshot)) {
+                processed[key] = snapshot;
+            }
         });
         return this.applySnapshotPostProcessor(processed);
     }
@@ -5003,11 +4987,9 @@ class ModelType extends ComplexType {
     }
     describe() {
         // optimization: cache
-        return ("{ " +
-            this.propertyNames
-                .map(key => key + ": " + this.properties[key].describe())
-                .join("; ") +
-            " }");
+        return `{ ${this.propertyNames
+            .map(key => `${key}: ${this.properties[key].describe()}`)
+            .join("; ")} }`;
     }
     getDefaultSnapshot() {
         return EMPTY_OBJECT;
@@ -5052,7 +5034,7 @@ function compose(...args) {
     }
     return args
         .reduce((prev, cur) => prev.cloneAndEnhance({
-        name: prev.name + "_" + cur.name,
+        name: `${prev.name}_${cur.name}`,
         properties: cur.properties,
         initializers: cur.initializers,
         preProcessor: (snapshot) => cur.applySnapshotPreProcessor(prev.applySnapshotPreProcessor(snapshot)),
@@ -5219,7 +5201,7 @@ function getPrimitiveFactoryFromValue(value) {
                 return DatePrimitive;
             }
     }
-    throw fail("Cannot determine primitive type from value " + value);
+    throw fail(`Cannot determine primitive type from value ${value}`);
 }
 /**
  * Returns if a given value represents a primitive type.
@@ -5395,7 +5377,7 @@ function enumeration(name, options) {
             assertIsString(option, i + 1);
         });
     }
-    const type = union(...realOptions.map(option => literal("" + option)));
+    const type = union(...realOptions.map(option => literal(`${option}`)));
     if (typeof name === "string") {
         type.name = name;
     }
@@ -5453,7 +5435,7 @@ class Union extends BaseType {
         return this._types.some(subType => subType.isAssignableFrom(type));
     }
     describe() {
-        return ("(" + this._types.map(factory => factory.describe()).join(" | ") + ")");
+        return `(${this._types.map(factory => factory.describe()).join(" | ")})`;
     }
     instantiate(parent, subpath, environment, initialValue) {
         const type = this.determineType(initialValue, undefined);
@@ -5495,8 +5477,7 @@ class Union extends BaseType {
         if (errors.length === 0) {
             return baseWithDiscriminator;
         }
-        return (`${baseWithDiscriminator}:\n    ` +
-            formatValidationErrorLines(errors).join("\n    "));
+        return `${baseWithDiscriminator}:\n    ${formatValidationErrorLines(errors).join("\n    ")}`;
     }
     _findCandidateByTypeDiscriminator(discriminator) {
         let found;
@@ -5726,7 +5707,7 @@ function union(optionsOrType, ...otherTypes) {
     const types = isType(optionsOrType)
         ? [optionsOrType, ...otherTypes]
         : otherTypes;
-    const name = "(" + types.map(type => type.name).join(" | ") + ")";
+    const name = `(${types.map(type => type.name).join(" | ")})`;
     // check all options
     if (devMode()) {
         if (options) {
@@ -5793,17 +5774,17 @@ class OptionalValue extends BaseType {
         this.optionalValues = optionalValues;
     }
     describe() {
-        return this._subtype.describe() + "?";
+        return `${this._subtype.describe()}?`;
     }
     instantiate(parent, subpath, environment, initialValue) {
-        if (this.optionalValues.indexOf(initialValue) >= 0) {
+        if (this.optionalValues.includes(initialValue)) {
             const defaultInstanceOrSnapshot = this.getDefaultInstanceOrSnapshot();
             return this._subtype.instantiate(parent, subpath, environment, defaultInstanceOrSnapshot);
         }
         return this._subtype.instantiate(parent, subpath, environment, initialValue);
     }
     reconcile(current, newValue, parent, subpath) {
-        return this._subtype.reconcile(current, this.optionalValues.indexOf(newValue) < 0 && this._subtype.is(newValue)
+        return this._subtype.reconcile(current, !this.optionalValues.includes(newValue) && this._subtype.is(newValue)
             ? newValue
             : this.getDefaultInstanceOrSnapshot(), parent, subpath);
     }
@@ -5820,7 +5801,7 @@ class OptionalValue extends BaseType {
     }
     isValidSnapshot(value, context) {
         // defaulted values can be skipped
-        if (this.optionalValues.indexOf(value) >= 0) {
+        if (this.optionalValues.includes(value)) {
             return typeCheckSuccess();
         }
         // bounce validation to the sub-type
@@ -5907,6 +5888,72 @@ const undefinedAsOptionalValues = [undefined];
 function isOptionalType(type) {
     return isType(type) && (type.flags & TypeFlags.Optional) > 0;
 }
+/**
+ * Compare a child snapshot to a stripped-default's reference snapshot. Mirrors
+ * the legacy hand-rolled comparison: identity for primitives, structural for
+ * objects/arrays.
+ */
+function defaultSnapshotEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (typeof a === "object" &&
+        a !== null &&
+        typeof b === "object" &&
+        b !== null) {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    return false;
+}
+/**
+ * An optional type that additionally omits its key from a parent model's
+ * snapshot when the value equals the (snapshotted) default. The comparison is
+ * against the default *snapshot* — i.e. the subtype is instantiated with the
+ * default once and its post-processed snapshot is cached — so a default whose
+ * normalized form gains fields (e.g. a fileLocation gaining `locationType`)
+ * still strips correctly.
+ *
+ * @hidden
+ * @internal
+ */
+class StripDefaultValue extends OptionalValue {
+    _defaultSnapshot;
+    shouldStripFromSnapshot(snapshot) {
+        if (!this._defaultSnapshot) {
+            // instantiate the subtype detached with the default and read the node's
+            // snapshot, which normalizes (fills model defaults, applies the subtype's
+            // own postProcess). Cached on the (singleton) type after first use.
+            const node = this.getSubTypes().instantiate(null, "", undefined, this.getDefaultInstanceOrSnapshot());
+            this._defaultSnapshot = { value: node.snapshot };
+        }
+        return defaultSnapshotEquals(snapshot, this._defaultSnapshot.value);
+    }
+}
+/**
+ * Whether `type` is a strip-default optional whose current child `snapshot`
+ * equals its default and should therefore be omitted from the parent model's
+ * snapshot. Used by `ModelType.getSnapshot`.
+ *
+ * @hidden
+ * @internal
+ */
+function shouldStripChildFromSnapshot(type, snapshot) {
+    return (type instanceof StripDefaultValue && type.shouldStripFromSnapshot(snapshot));
+}
+/**
+ * `types.stripDefault` - Like `types.optional`, but the property is omitted from
+ * a parent model's snapshot entirely when its value equals the default (instead
+ * of being serialized with the default value). Lets a model produce minimal
+ * snapshots without a bespoke `postProcessSnapshot`.
+ *
+ * @param type
+ * @param defaultValueOrFunction
+ * @returns
+ */
+function stripDefault(type, defaultValueOrFunction) {
+    checkOptionalPreconditions(type, defaultValueOrFunction);
+    return new StripDefaultValue(type, defaultValueOrFunction, undefinedAsOptionalValues);
+}
 
 const optionalUndefinedType = optional(undefinedType, undefined);
 const optionalNullType = optional(nullType, null);
@@ -6021,8 +6068,7 @@ function late(nameOrType, maybeType) {
     // checks that the type is actually a late type
     if (devMode()) {
         if (!(typeof type === "function" && type.length === 0)) {
-            throw fail("Invalid late type, expected a function with zero arguments that returns a type, got: " +
-                type);
+            throw fail(`Invalid late type, expected a function with zero arguments that returns a type, got: ${type}`);
         }
     }
     return new Late(name, type);
@@ -6235,8 +6281,7 @@ class StoredReference {
         const normalizedId = normalizeIdentifier(this.identifier);
         const root = node.root;
         const lastCacheModification = root.identifierCache.getLastCacheModificationPerId(normalizedId);
-        if (!this.resolvedReference ||
-            this.resolvedReference.lastCacheModification !== lastCacheModification) {
+        if (this.resolvedReference?.lastCacheModification !== lastCacheModification) {
             const { targetType } = this;
             // reference was initialized with the identifier of the target
             const target = root.identifierCache.resolve(targetType, normalizedId);
@@ -6245,7 +6290,7 @@ class StoredReference {
             }
             this.resolvedReference = {
                 node: target,
-                lastCacheModification: lastCacheModification
+                lastCacheModification
             };
         }
     }
@@ -6293,7 +6338,7 @@ class BaseReferenceType extends SimpleType {
         // since it is a scalar value (immutable-ish) and we need to change it
         // from the parent
         const storedRefParentNode = storedRefNode.parent;
-        if (!storedRefParentNode || !storedRefParentNode.isAlive) {
+        if (!storedRefParentNode?.isAlive) {
             return;
         }
         const storedRefParentValue = storedRefParentNode.storedValue;
@@ -6365,7 +6410,7 @@ class BaseReferenceType extends SimpleType {
             }
             // make sure the target node is actually there and initialized
             const storedRefParentNode = storedRefNode.parent;
-            const storedRefParentValue = storedRefParentNode && storedRefParentNode.storedValue;
+            const storedRefParentValue = storedRefParentNode?.storedValue;
             if (storedRefParentNode &&
                 storedRefParentNode.isAlive &&
                 storedRefParentValue) {
@@ -6679,7 +6724,7 @@ function isIdentifierType(type) {
  * @hidden
  */
 function normalizeIdentifier(id) {
-    return "" + id;
+    return `${id}`;
 }
 /**
  * @internal
@@ -6775,7 +6820,7 @@ class CustomType extends SimpleType {
     instantiate(parent, subpath, environment, initialValue) {
         const valueToStore = this.options.isTargetType(initialValue)
             ? initialValue
-            : this.options.fromSnapshot(initialValue, parent && parent.root.environment);
+            : this.options.fromSnapshot(initialValue, parent?.root.environment);
         return createScalarNode(this, parent, subpath, environment, valueToStore);
     }
     reconcile(current, value, parent, subpath) {
@@ -6926,6 +6971,7 @@ const types = {
     safeReference,
     union,
     optional,
+    stripDefault,
     literal,
     maybe,
     maybeNull,
@@ -7019,6 +7065,7 @@ exports.resolvePath = resolvePath;
 exports.setDevMode = setDevMode;
 exports.setLivelinessChecking = setLivelinessChecking;
 exports.setLivelynessChecking = setLivelynessChecking;
+exports.setTypeChecking = setTypeChecking;
 exports.splitJsonPath = splitJsonPath;
 exports.t = types;
 exports.toGenerator = toGenerator;