mutate-cow 8.0.0 → 8.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mutate-cow",
-  "version": "8.0.0",
+  "version": "8.1.0",
   "description": "Update immutable objects as if they were mutable with copy-on-write",
   "keywords": [
     "immutable",
@@ -18,7 +18,7 @@
   },
   "devDependencies": {
     "benchmark": "2.1.4",
-    "flow-bin": "0.275.0",
+    "flow-bin": "0.290.0",
     "immer": "10.1.1",
     "mutative": "1.2.0",
     "tsd": "0.29.0"

package/src/index.js

@@ -5,6 +5,8 @@
  * in the file named "LICENSE" at the root directory of this distribution.
  */
 
+const EMPTY_OBJECT = Object.freeze({});
+
 const NATIVE_CODE_REGEXP = /^function \w*\(\) \{\s*\[native code\]\s*\}$/m;
 
 const STATUS_NONE = 1;
@@ -27,20 +29,19 @@ function isCloneableObject(object) {
   let proto = Object.getPrototypeOf(object);
   while (proto) {
     let ctor = proto.constructor;
-    if (!ctor) {
-      continue;
-    }
-    // A Generator object's constructor is an object.
-    if (typeof ctor === 'object') {
-      ctor = ctor.constructor;
-    }
-    if (
-      typeof ctor === 'function' &&
-      ctor.name !== 'Array' &&
-      ctor.name !== 'Object' &&
-      NATIVE_CODE_REGEXP.test(Function.prototype.toString.call(ctor))
-    ) {
-      return false;
+    if (ctor) {
+      // A Generator object's constructor is an object.
+      if (typeof ctor === 'object') {
+        ctor = ctor.constructor;
+      }
+      if (
+        typeof ctor === 'function' &&
+        ctor.name !== 'Array' &&
+        ctor.name !== 'Object' &&
+        NATIVE_CODE_REGEXP.test(Function.prototype.toString.call(ctor))
+      ) {
+        return false;
+      }
     }
     proto = Object.getPrototypeOf(proto);
   }
@@ -55,7 +56,7 @@ function printConstructor(object) {
     case 'object':
       return Object.prototype.toString.call(ctor);
     default:
-      return '';
+      return '[primitive constructor]';
   }
 }
 
@@ -70,125 +71,50 @@ function restoreDescriptors(copy, changedDescriptors) {
   }
 }
 
-function clone(context) {
-  const source = context._getSource();
-  if (isPrimitive(source)) {
-    return source;
-  }
-  if (!isCloneableObject(source)) {
-    throw new Error(
-      printConstructor(source) +
-      ' objects are not supported for cloning.',
-    );
-  }
-  if (context._strict) {
-    return cloneObjectStrict(source, context);
-  }
-  return cloneObjectLoose(source);
-}
-
-function cloneObjectLoose(source) {
-  if (Array.isArray(source)) {
-    return source.slice();
-  }
-  return {...source};
-}
-
-function cloneObjectStrict(source, context) {
-  if (!context._callbacks) {
-    context._callbacks = [];
-  }
-  const proto = Object.getPrototypeOf(source);
-  let changedDescriptors = [];
-  let copy;
-  if (Array.isArray(source)) {
-    copy = Reflect.construct(Array, source, proto.constructor);
-  } else {
-    copy = Object.create(proto);
-  }
-  const ownKeys = Reflect.ownKeys(source);
-  for (let i = 0; i < ownKeys.length; i++) {
-    const key = ownKeys[i];
-    const descriptor = Object.getOwnPropertyDescriptor(source, key);
-    let origDesc;
-    if (descriptor.configurable === false) {
-      descriptor.configurable = true;
-      origDesc = {configurable: false};
-    }
-    if (descriptor.writable === false) {
-      descriptor.writable = true;
-      origDesc = {...origDesc, writable: false};
-    }
-    if (origDesc) {
-      changedDescriptors.push([key, origDesc]);
-    }
-    Reflect.defineProperty(copy, key, descriptor);
-  }
-  if (changedDescriptors.length) {
-    context._callbacks.push({
-      func: restoreDescriptors,
-      args: [copy, changedDescriptors],
-    });
-  }
-  if (Object.isFrozen(source)) {
-    context._callbacks.push({
-      func: Object.freeze,
-      args: [copy],
-    });
-  } else if (Object.isSealed(source)) {
-    context._callbacks.push({
-      func: Object.seal,
-      args: [copy],
-    });
-  } else if (!Object.isExtensible(source)) {
-    context._callbacks.push({
-      func: Object.preventExtensions,
-      args: [copy],
-    });
-  }
-  return copy;
-}
-
 export class CowContext {
-  constructor(source, prop, parent, strict = false) {
+  constructor(source, prop, parent) {
     this._source = source;
     this._prop = prop;
     this._parent = parent;
-    this._callbacks = null;
     this._result = null;
     this._status = STATUS_NONE;
     this._children = null;
-    this._strict = strict;
   }
 
-  _copyForWrite() {
-    const status = this._status;
-    if (
-      status === STATUS_MUTABLE ||
-      status === STATUS_REVOKED
-    ) {
+  _copyForWrite(forceObject) {
+    if (this._status === STATUS_MUTABLE || this._status === STATUS_REVOKED) {
       return;
     }
-    const stack = [];
-    let parent = this;
-    while (parent && parent._status !== STATUS_MUTABLE) {
-      stack.push(parent);
-      parent = parent._parent;
-    }
-    for (let i = stack.length - 1; i >= 0; i--) {
-      const context = stack[i];
-      if (!context._result) {
-        context._result = clone(context);
+    if (!this._result) {
+      const source = this._getSource();
+      if (isPrimitive(source)) {
+        this._result = forceObject ? {} : source;
+      } else if (!isCloneableObject(source)) {
+        throw new Error(
+          printConstructor(source) +
+          ' objects are not supported for cloning.',
+        );
+      } else {
+        this._result = this._cloneSourceObject(source);
       }
-      if (context._parent) {
-        context._parent._result[context._prop] = context._result;
-      }
-      context._status = STATUS_MUTABLE;
     }
+    const parent = this._parent;
+    if (parent) {
+      parent._copyForWrite(/* forceObject = */ true);
+      parent._result[this._prop] = this._result;
+    }
+    this._status = STATUS_MUTABLE;
+  }
+
+  _cloneSourceObject(source) {
+    if (Array.isArray(source)) {
+      return source.slice();
+    }
+    return {...source};
   }
 
   _getPropValue(prop) {
-    return Reflect.get(this._read(), prop);
+    return Reflect.get(this._read() ?? EMPTY_OBJECT, prop);
   }
 
   _getSource() {
@@ -222,7 +148,7 @@ export class CowContext {
 
   write() {
     this._throwIfRevoked();
-    this._copyForWrite();
+    this._copyForWrite(/* forceObject = */ false);
     return this._result;
   }
 
@@ -240,7 +166,7 @@ export class CowContext {
       return child;
     }
 
-    child = new CowContext(value, prop, this, this._strict);
+    child = new this.constructor(value, prop, this);
     children.set(prop, child);
     return child;
   }
@@ -261,7 +187,6 @@ export class CowContext {
     } else {
       this._source = value;
       this._status = STATUS_NONE;
-      this._callbacks = null;
       this._result = null;
       // Child source values must be invalidated, because they can
       // reference a previous copy we made.
@@ -270,7 +195,7 @@ export class CowContext {
   }
 
   _set(prop, newValue) {
-    this._copyForWrite();
+    this._copyForWrite(/* forceObject = */ true);
     this._result[prop] = newValue;
 
     // Child source values must be invalidated, because they can
@@ -285,9 +210,10 @@ export class CowContext {
   }
 
   _setIfChanged(prop, newValue) {
+    const object = this._read() ?? EMPTY_OBJECT;
     if (
-      !Object.hasOwn(this._read(), prop) ||
-      !Object.is(this._getPropValue(prop), newValue)
+      !Object.hasOwn(object, prop) ||
+      !Object.is(Reflect.get(object, prop), newValue)
     ) {
       this._set(prop, newValue);
     }
@@ -295,7 +221,6 @@ export class CowContext {
 
   _setStale() {
     this._source = null;
-    this._callbacks = null;
     this._result = null;
     this._status = STATUS_STALE;
     this._setAllChildrenAsStale();
@@ -341,7 +266,6 @@ export class CowContext {
     this._source = source;
     this._result = mutableValue;
     this._status = STATUS_MUTABLE;
-    this._callbacks = null;
     this._setAllChildrenAsStale();
   }
 
@@ -359,27 +283,31 @@ export class CowContext {
     return root;
   }
 
-  revoke() {
+  _revoke(recursive) {
     if (this.isRevoked()) {
       return;
     }
     if (this._parent) {
       this._parent._children.delete(this._prop);
     }
-    if (this._children) {
-      for (const child of this._children.values()) {
-        child.revoke();
+    if (recursive && this._children) {
+      const childrenToRevoke = [...this._children.values()];
+      for (const child of childrenToRevoke) {
+        child._revoke(true);
       }
-      this._children = null;
     }
+    this._children = null;
     this._source = null;
     this._prop = null;
     this._parent = null;
-    this._callbacks = null;
     this._result = null;
     this._status = STATUS_REVOKED;
   }
 
+  revoke() {
+    this._revoke(/* recursive = */ true);
+  }
+
   isRevoked() {
     return this._status === STATUS_REVOKED;
   }
@@ -387,13 +315,107 @@ export class CowContext {
   final() {
     this._throwIfRevoked();
     if (this._children) {
-      for (const child of this._children.values()) {
+      const childrenToFinalize = [...this._children.values()];
+      for (const child of childrenToFinalize) {
         child.final();
       }
     }
     const result = this._read();
+    this._revoke(/* recursive = */ false);
+    return result;
+  }
+
+  finalRoot() {
+    return this.root().final();
+  }
+}
+
+class CowContextStrict extends CowContext {
+  constructor(source, prop, parent) {
+    super(source, prop, parent);
+    this._callbacks = null;
+  }
+
+  _replace(value) {
+    super._replace(value);
+    if (!this._parent) {
+      this._callbacks = null;
+    }
+  }
+
+  _setStale() {
+    super._setStale();
+    this._callbacks = null;
+  }
+
+  _cloneSourceObject(source) {
+    if (!this._callbacks) {
+      this._callbacks = [];
+    }
+    const proto = Object.getPrototypeOf(source);
+    let changedDescriptors = [];
+    let copy;
+    if (Array.isArray(source)) {
+      copy = Reflect.construct(Array, source, proto.constructor);
+    } else {
+      copy = Object.create(proto);
+    }
+    const ownKeys = Reflect.ownKeys(source);
+    for (let i = 0; i < ownKeys.length; i++) {
+      const key = ownKeys[i];
+      const descriptor = Object.getOwnPropertyDescriptor(source, key);
+      let origDesc;
+      if (descriptor.configurable === false) {
+        descriptor.configurable = true;
+        origDesc = {configurable: false};
+      }
+      if (descriptor.writable === false) {
+        descriptor.writable = true;
+        origDesc = {...origDesc, writable: false};
+      }
+      if (origDesc) {
+        changedDescriptors.push([key, origDesc]);
+      }
+      Reflect.defineProperty(copy, key, descriptor);
+    }
+    if (changedDescriptors.length) {
+      this._callbacks.push({
+        func: restoreDescriptors,
+        args: [copy, changedDescriptors],
+      });
+    }
+    if (Object.isFrozen(source)) {
+      this._callbacks.push({
+        func: Object.freeze,
+        args: [copy],
+      });
+    } else if (Object.isSealed(source)) {
+      this._callbacks.push({
+        func: Object.seal,
+        args: [copy],
+      });
+    } else if (!Object.isExtensible(source)) {
+      this._callbacks.push({
+        func: Object.preventExtensions,
+        args: [copy],
+      });
+    }
+    return copy;
+  }
+
+  dangerouslySetAsMutable() {
+    super.dangerouslySetAsMutable();
+    this._callbacks = null;
+  }
+
+  revoke() {
+    super.revoke();
+    this._callbacks = null;
+  }
+
+  final() {
     const callbacks = this._callbacks;
-    this.revoke();
+    const result = super.final();
     if (callbacks) {
       for (let i = 0; i < callbacks.length; i++) {
         const {func, args} = callbacks[i];
@@ -402,12 +424,12 @@ export class CowContext {
     }
     return result;
   }
-
-  finalRoot() {
-    return this.root().final();
-  }
 }
 
 export default function mutate(source, strict = false) {
-  return new CowContext(source, null, null, strict);
+  if (strict) {
+    return new CowContextStrict(source, null, null);
+  } else {
+    return new CowContext(source, null, null);
+  }
 }