@jbrowse/mobx-state-tree 5.10.8 → 5.11.1

package/dist/mobx-state-tree.mjs

@@ -4903,7 +4903,7 @@ class ModelType extends ComplexType {
     }
     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 = getAtom(node.storedValue, name);
@@ -4912,7 +4912,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);
@@ -4922,7 +4926,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);
     }
@@ -5876,6 +5886,84 @@ 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) {
+        // Cheap structural short-circuit before the full stringify compare: a
+        // value of a different size can't equal the default, so the common strip
+        // case (non-empty value vs an empty `[]`/`{}` default) avoids stringifying
+        // a potentially large snapshot on every getSnapshot.
+        if (Array.isArray(a) !== Array.isArray(b)) {
+            return false;
+        }
+        const aSize = Array.isArray(a) ? a.length : Object.keys(a).length;
+        const bSize = Array.isArray(b) ? b.length : Object.keys(b).length;
+        if (aSize !== bSize) {
+            return false;
+        }
+        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);
@@ -6893,6 +6981,7 @@ const types = {
     safeReference,
     union,
     optional,
+    stripDefault,
     literal,
     maybe,
     maybeNull,