@jbrowse/mobx-state-tree 5.10.8 → 5.11.0

package/dist/index.d.ts

@@ -1921,6 +1921,17 @@ declare function optional<IT extends IAnyType, OptionalVals extends ValidOptiona
  * @returns
  */
 declare function isOptionalType<IT extends IAnyType>(type: IT): type is IT;
+/**
+ * `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
+ */
+declare function stripDefault<IT extends IAnyType>(type: IT, defaultValueOrFunction: OptionalDefaultValueOrFunction<IT>): IOptionalIType<IT, [undefined]>;
 
 /** @hidden */
 interface IMaybeIType<IT extends IAnyType, C, O> extends IType<IT["CreationType"] | C, IT["SnapshotType"] | O, IT["TypeWithoutSTN"] | O> {
@@ -2149,6 +2160,7 @@ declare const types: {
     safeReference: typeof safeReference;
     union: typeof union;
     optional: typeof optional;
+    stripDefault: typeof stripDefault;
     literal: typeof literal;
     maybe: typeof maybe;
     maybeNull: typeof maybeNull;

package/dist/mobx-state-tree.cjs

@@ -4905,7 +4905,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 = mobx.getAtom(node.storedValue, name);
@@ -4914,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);
@@ -4924,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);
     }
@@ -5878,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);
@@ -6895,6 +6971,7 @@ const types = {
     safeReference,
     union,
     optional,
+    stripDefault,
     literal,
     maybe,
     maybeNull,