mutate-cow 5.0.0 → 7.0.0

package/README.md

@@ -67,7 +67,7 @@ Passing zero arguments returns `ctx`.
 ```js
 ctx.get() === ctx;
 ctx.get('bar').read() === foo.bar;
-ctx.get('bar', 'baz').read() === '';
+ctx.get('bar', 'baz').read().length === 0;
 ```
 
 ### ctx.set(...path: [prop1, ...], value)
@@ -77,13 +77,14 @@ Sets the given `path` to `value` on the current working copy. Returns `ctx`.
 Passing zero property names (i.e., only a value) sets the current context's value.
 
 ```js
+const qux = ['qux'];
 // these all do the same thing
-ctx.set({bar: {baz: 2}});
-ctx.set('bar', {baz: 2});
-ctx.set('bar', 'baz', 2);
-ctx.get('bar').set({baz: 2});
-ctx.get('bar').set('baz', 2);
-ctx.get('bar', 'baz').set(2);
+ctx.set({bar: {baz: qux}});
+ctx.set('bar', {baz: qux});
+ctx.set('bar', 'baz', qux);
+ctx.get('bar').set({baz: qux});
+ctx.get('bar').set('baz', qux);
+ctx.get('bar', 'baz').set(qux);
 ```
 
 ### ctx.update(...path: [prop1, ...], updater)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mutate-cow",
-  "version": "5.0.0",
+  "version": "7.0.0",
   "description": "Update immutable objects as if they were mutable with copy-on-write",
   "keywords": [
     "immutable",
@@ -8,8 +8,8 @@
     "copy on write",
     "state management"
   ],
-  "main": "index.mjs",
-  "types": "index.d.ts",
+  "main": "src/index.js",
+  "types": "types/index.d.ts",
   "license": "MIT",
   "author": "Michael Wiencek <mwtuea@gmail.com>",
   "repository": {
@@ -18,11 +18,15 @@
   },
   "devDependencies": {
     "benchmark": "2.1.4",
-    "flow-bin": "0.222.0",
+    "flow-bin": "0.275.0",
+    "immer": "10.1.1",
+    "mutative": "1.2.0",
     "tsd": "0.29.0"
   },
   "sideEffects": false,
+  "type": "module",
   "scripts": {
-    "test": "node --test --experimental-test-coverage"
-  }
+    "test": "node --test --experimental-test-coverage test/index.js"
+  },
+  "packageManager": "yarn@4.9.2+sha512.1fc009bc09d13cfd0e19efa44cbfc2b9cf6ca61482725eb35bbc5e257e093ebf4130db6dfe15d604ff4b79efd8e1e8e99b25fa7d0a6197c9f9826358d4d65c3c"
 }

package/{CowContext.mjs → src/index.js}

@@ -5,20 +5,130 @@
  * in the file named "LICENSE" at the root directory of this distribution.
  */
 
-import clone from './clone.mjs';
-import {
-  STATUS_CHANGED,
-  STATUS_NONE,
-  STATUS_REVOKED,
-} from './constants.mjs';
+const NATIVE_CODE_REGEXP = /^function \w*\(\) \{\s*\[native code\]\s*\}$/m;
 
-const STALE_VALUE = Object.freeze(Object.create(null));
+const STATUS_NONE = 1;
+const STATUS_CHANGED = 2;
+const STATUS_REVOKED = 3;
+const STATUS_STALE = 4;
 
-export default class CowContext {
-  constructor(source, prop, root, parent) {
+function isPrimitive(value) {
+  if (value === null) {
+    return true;
+  }
+  const type = typeof value;
+  return (type !== 'function' && type !== 'object');
+}
+
+function getCloneableType(value) {
+  if (isPrimitive(value)) {
+    return 1;
+  }
+  if (typeof value !== 'object') {
+    return 0;
+  }
+  let proto = Object.getPrototypeOf(value);
+  while (proto) {
+    let ctor = proto.constructor;
+    // A Generator object's constructor is an object.
+    if (ctor && 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 0;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return 2;
+}
+
+function throwIfTypeNotCloneable(cloneableType) {
+  if (cloneableType === 0) {
+    throw new Error(
+      'Only plain objects, arrays, and class instances ' +
+      'can be cloned. Primitives, functions, and built-ins ' +
+      'are unsupported.',
+    );
+  }
+}
+
+function restoreDescriptors(copy, changedDescriptors) {
+  for (let i = 0; i < changedDescriptors.length; i++) {
+    const [name, origDesc] = changedDescriptors[i];
+    const descriptor = Object.getOwnPropertyDescriptor(copy, name);
+    if (descriptor) {
+      Object.assign(descriptor, origDesc);
+      Reflect.defineProperty(copy, name, descriptor);
+    }
+  }
+}
+
+function clone(source, callbacks) {
+  const cloneableType = getCloneableType(source);
+  throwIfTypeNotCloneable(cloneableType);
+  if (cloneableType === 1) {
+    return source;
+  }
+  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) {
+    callbacks.push({
+      func: restoreDescriptors,
+      args: [copy, changedDescriptors],
+    });
+  }
+  if (Object.isFrozen(source)) {
+    callbacks.push({
+      func: Object.freeze,
+      args: [copy],
+    });
+  } else if (Object.isSealed(source)) {
+    callbacks.push({
+      func: Object.seal,
+      args: [copy],
+    });
+  } else if (!Object.isExtensible(source)) {
+    callbacks.push({
+      func: Object.preventExtensions,
+      args: [copy],
+    });
+  }
+  return copy;
+}
+
+export class CowContext {
+  constructor(source, prop, parent) {
     this._source = source;
     this._prop = prop;
-    this._root = root || this;
     this._parent = parent;
     this._callbacks = [];
     this._result = null;
@@ -52,8 +162,7 @@ export default class CowContext {
     }
   }
 
-  _getPropValue(prop) {
-    const target = this.read();
+  _getPropDescriptor(target, prop) {
     const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
     if (descriptor) {
       if (descriptor.get) {
@@ -62,22 +171,29 @@ export default class CowContext {
       if (descriptor.set) {
         throw new Error('Setters are unsupported.');
       }
+      return descriptor;
+    }
+  }
+
+  _getPropValue(prop) {
+    const target = this.read();
+    const descriptor = this._getPropDescriptor(target, prop);
+    if (descriptor) {
       return descriptor.value;
     }
     return Reflect.get(target, prop);
   }
 
   _getSource() {
-    let source = this._source;
-    if (source === STALE_VALUE) {
+    if (this._status === STATUS_STALE) {
       /*
        * `this._parent` should always be defined here, because we only
-       * ever assign `STALE_VALUE` onto child contexts.
+       * ever set `STATUS_STALE` onto child contexts.
        */
-      source = this._parent._getPropValue(this._prop);
-      this._source = source;
+      this._source = this._parent._getPropValue(this._prop);
+      this._status = STATUS_NONE;
     }
-    return source;
+    return this._source;
   }
 
   _throwIfRevoked() {
@@ -113,7 +229,7 @@ export default class CowContext {
       return child;
     }
 
-    child = new CowContext(value, prop, this._root, this);
+    child = new CowContext(value, prop, this);
     children.set(prop, child);
     return child;
   }
@@ -136,9 +252,8 @@ export default class CowContext {
   }
 
   _set(prop, newValue) {
-    const origValue = this._getPropValue(prop);
-
-    if (!Object.is(origValue, newValue)) {
+    const descriptor = this._getPropDescriptor(this.read(), prop);
+    if (descriptor === undefined || !Object.is(descriptor.value, newValue)) {
       this._copyForWrite();
       this._result[prop] = newValue;
 
@@ -148,10 +263,10 @@ export default class CowContext {
       if (children) {
         const child = children.get(prop);
         if (child) {
-          child._source = STALE_VALUE;
+          child._source = null;
           child._callbacks = [];
           child._result = null;
-          child._status = STATUS_NONE;
+          child._status = STATUS_STALE;
         }
       }
     }
@@ -186,7 +301,11 @@ export default class CowContext {
 
   root() {
     this._throwIfRevoked();
-    return this._root;
+    let root = this;
+    while (root._parent !== null) {
+      root = root._parent;
+    }
+    return root;
   }
 
   revoke() {
@@ -204,7 +323,6 @@ export default class CowContext {
     }
     this._source = null;
     this._prop = null;
-    this._root = null;
     this._parent = null;
     this._callbacks = null;
     this._result = null;
@@ -236,3 +354,8 @@ export default class CowContext {
     return this.root().final();
   }
 }
+
+export default function mutate(source) {
+  throwIfTypeNotCloneable(getCloneableType(source));
+  return new CowContext(source, null, null);
+}

package/src/index.js.flow

@@ -0,0 +1,114 @@
+// @flow strict
+
+export type KeyType<+T> =
+  T extends $ReadOnlyArray<mixed> ? number :
+  T extends ({__proto__: null, ...} | interface {}) ? $Keys<T> :
+  empty;
+export type KeyType2<+T, +K1: KeyType<T>> = KeyType<PropType<T, K1>>;
+export type KeyType3<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>> = KeyType<PropType2<T, K1, K2>>;
+export type KeyType4<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>> = KeyType<PropType3<T, K1, K2, K3>>;
+export type KeyType5<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>, +K4: KeyType4<T, K1, K2, K3>> = KeyType<PropType4<T, K1, K2, K3, K4>>;
+export type KeyType6<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>, +K4: KeyType4<T, K1, K2, K3>, +K5: KeyType5<T, K1, K2, K3, K4>> = KeyType<PropType5<T, K1, K2, K3, K4, K5>>;
+export type KeyType7<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>, +K4: KeyType4<T, K1, K2, K3>, +K5: KeyType5<T, K1, K2, K3, K4>, +K6: KeyType6<T, K1, K2, K3, K4, K5>> = KeyType<PropType6<T, K1, K2, K3, K4, K5, K6>>;
+export type KeyType8<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>, +K4: KeyType4<T, K1, K2, K3>, +K5: KeyType5<T, K1, K2, K3, K4>, +K6: KeyType6<T, K1, K2, K3, K4, K5>, +K7: KeyType7<T, K1, K2, K3, K4, K5, K6>> = KeyType<PropType7<T, K1, K2, K3, K4, K5, K6, K7>>;
+
+export type PropType<+T, +K: KeyType<T>> =
+  T extends $ReadOnlyArray<infer V> ? V :
+  T extends ({__proto__: null, ...} | interface {}) ? T[K] :
+  empty;
+export type PropType2<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>> =
+  PropType<PropType<T, K1>, K2>;
+export type PropType3<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>> =
+  PropType<PropType2<T, K1, K2>, K3>;
+export type PropType4<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>, +K4: KeyType4<T, K1, K2, K3>> =
+  PropType<PropType3<T, K1, K2, K3>, K4>;
+export type PropType5<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>, +K4: KeyType4<T, K1, K2, K3>, +K5: KeyType5<T, K1, K2, K3, K4>> =
+  PropType<PropType4<T, K1, K2, K3, K4>, K5>;
+export type PropType6<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>, +K4: KeyType4<T, K1, K2, K3>, +K5: KeyType5<T, K1, K2, K3, K4>, +K6: KeyType6<T, K1, K2, K3, K4, K5>> =
+  PropType<PropType5<T, K1, K2, K3, K4, K5>, K6>;
+export type PropType7<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>, +K4: KeyType4<T, K1, K2, K3>, +K5: KeyType5<T, K1, K2, K3, K4>, +K6: KeyType6<T, K1, K2, K3, K4, K5>, +K7: KeyType7<T, K1, K2, K3, K4, K5, K6>> =
+  PropType<PropType6<T, K1, K2, K3, K4, K5, K6>, K7>;
+export type PropType8<+T, +K1: KeyType<T>, +K2: KeyType2<T, K1>, +K3: KeyType3<T, K1, K2>, +K4: KeyType4<T, K1, K2, K3>, +K5: KeyType5<T, K1, K2, K3, K4>, +K6: KeyType6<T, K1, K2, K3, K4, K5>, +K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, +K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>> =
+  PropType<PropType7<T, K1, K2, K3, K4, K5, K6, K7>, K8>;
+
+export type ShallowReadWrite<+T> =
+  T extends $ReadOnlyArray<infer V> ? Array<V> :
+  T extends {__proto__: null, ...} ? {__proto__: null, ...T} :
+  T extends {...} ? {...T} :
+  T;
+
+export type CowRootContext<+R> = CowContext<R, null>;
+
+export type CowAnyContext = CowContext<mixed, CowAnyContext | null>;
+
+type $Get1<+T, +K1, +ThisContext> =
+  CowContext<PropType<T, K1>, ThisContext>;
+type $Get2<+T, +K1, +K2, +ThisContext> =
+  CowContext<PropType2<T, K1, K2>, $Get1<T, K1, ThisContext>>;
+type $Get3<+T, +K1, +K2, +K3, +ThisContext> =
+  CowContext<PropType3<T, K1, K2, K3>, $Get2<T, K1, K2, ThisContext>>;
+type $Get4<+T, +K1, +K2, +K3, +K4, +ThisContext> =
+  CowContext<PropType4<T, K1, K2, K3, K4>, $Get3<T, K1, K2, K3, ThisContext>>;
+type $Get5<+T, +K1, +K2, +K3, +K4, +K5, +ThisContext> =
+  CowContext<PropType5<T, K1, K2, K3, K4, K5>, $Get4<T, K1, K2, K3, K4, ThisContext>>;
+type $Get6<+T, +K1, +K2, +K3, +K4, +K5, +K6, +ThisContext> =
+  CowContext<PropType6<T, K1, K2, K3, K4, K5, K6>, $Get5<T, K1, K2, K3, K4, K5, ThisContext>>;
+type $Get7<+T, +K1, +K2, +K3, +K4, +K5, +K6, +K7, +ThisContext> =
+  CowContext<PropType7<T, K1, K2, K3, K4, K5, K6, K7>, $Get6<T, K1, K2, K3, K4, K5, K6, ThisContext>>;
+type $Get8<+T, +K1, +K2, +K3, +K4, +K5, +K6, +K7, +K8, +ThisContext> =
+  CowContext<PropType8<T, K1, K2, K3, K4, K5, K6, K7, K8>, $Get7<T, K1, K2, K3, K4, K5, K6, K7, ThisContext>>;
+
+export type GetCowContextSource<+C> =
+  C extends CowContext<infer T, mixed>
+    ? T
+    : empty;
+
+export type GetCowContextRoot<+C> =
+  C extends CowContext<infer T, infer P>
+    ? (P extends null ? C : GetCowContextRoot<P>)
+    : empty;
+
+declare class CowContext<
+ +T,
+ +ParentContext: CowAnyContext | null = CowAnyContext | null,
+>{
+  read(): T;
+  write(): ShallowReadWrite<T>;
+  get(): this;
+  get<const K1: KeyType<T>>(prop1: K1): $Get1<T, K1, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>>(prop1: K1, prop2: K2): $Get2<T, K1, K2, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>>(prop1: K1, prop2: K2, prop3: K3): $Get3<T, K1, K2, K3, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4): $Get4<T, K1, K2, K3, K4, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5): $Get5<T, K1, K2, K3, K4, K5, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6): $Get6<T, K1, K2, K3, K4, K5, K6, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7): $Get7<T, K1, K2, K3, K4, K5, K6, K7, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, const K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, prop8: K8): $Get8<T, K1, K2, K3, K4, K5, K6, K7, K8, this>;
+  set(newValue: T): this;
+  set<const K1: KeyType<T>>(prop1: K1, newValue: PropType<T, K1>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>>(prop1: K1, prop2: K2, newValue: PropType2<T, K1, K2>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>>(prop1: K1, prop2: K2, prop3: K3, newValue: PropType3<T, K1, K2, K3>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, newValue: PropType4<T, K1, K2, K3, K4>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, newValue: PropType5<T, K1, K2, K3, K4, K5>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, newValue: PropType6<T, K1, K2, K3, K4, K5, K6>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, newValue: PropType7<T, K1, K2, K3, K4, K5, K6, K7>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, const K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, prop8: K8, newValue: PropType8<T, K1, K2, K3, K4, K5, K6, K7, K8>): this;
+  update(updater: (this) => mixed): this;
+  update<const K1: KeyType<T>>(prop1: K1, updater: ($Get1<T, K1, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>>(prop1: K1, prop2: K2, updater: ($Get2<T, K1, K2, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>>(prop1: K1, prop2: K2, prop3: K3, updater: ($Get3<T, K1, K2, K3, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, updater: ($Get4<T, K1, K2, K3, K4, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, updater: ($Get5<T, K1, K2, K3, K4, K5, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, updater: ($Get6<T, K1, K2, K3, K4, K5, K6, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, updater: ($Get7<T, K1, K2, K3, K4, K5, K6, K7, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, const K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, prop8: K8, updater: ($Get8<T, K1, K2, K3, K4, K5, K6, K7, K8, this>) => mixed): this;
+  parent(): ParentContext;
+  root(): GetCowContextRoot<this>;
+  revoke(): void;
+  isRevoked(): boolean;
+  final(): T;
+  finalRoot(): GetCowContextSource<GetCowContextRoot<this>>;
+}
+
+declare export default function mutate<T>(
+  source: T,
+): CowRootContext<T>;

package/{index.d.ts → types/index.d.ts}

@@ -7,43 +7,53 @@ type NestedProp<T, Path extends ReadonlyArray<PropertyKey>> =
     )
     : T;
 
-type NestedContext<T, R extends object, ParentContext extends CowAnyContext<R> | null, Path extends ReadonlyArray<PropertyKey>> =
+type NestedContext<T, ParentContext extends CowAnyContext | null, Path extends ReadonlyArray<PropertyKey>> =
   Path extends [infer First, ...infer Rest]
     ? (
       First extends keyof T
-        ? NestedContext<T[First], R, CowContext<T, R, ParentContext>, Extract<Rest, ReadonlyArray<PropertyKey>>>
+        ? NestedContext<T[First], CowContext<T, ParentContext>, Extract<Rest, ReadonlyArray<PropertyKey>>>
         : never
     )
-    : CowContext<T, R, ParentContext>;
+    : CowContext<T, ParentContext>;
 
 type ShallowReadWrite<T> =
   T extends ReadonlyArray<infer V> ? Array<V> :
   T extends object ? {-readonly [K in keyof T]: T[K]} : never;
 
-type CowRootContext<R extends object> = CowContext<R, R, null>;
+type CowRootContext<R> = CowContext<R, null>;
 
-type CowAnyContext<R extends object> =
-  CowContext<unknown, R, CowAnyContext<R> | null>;
+type CowAnyContext =
+  CowContext<unknown, CowAnyContext | null>;
+
+type GetCowContextSource<C> =
+  C extends CowContext<infer T, CowAnyContext | null>
+    ? T
+    : never;
+
+type GetCowContextRoot<C> =
+  C extends CowContext<infer T, infer P>
+    ? (P extends null ? C : GetCowContextRoot<P>)
+    : never;
 
 declare class CowContext<
   out T,
-  out R extends object,
-  out ParentContext extends CowAnyContext<R> | null = CowAnyContext<R> | null,
+  // @ts-ignore
+  out ParentContext extends CowAnyContext | null = CowAnyContext | null,
 > {
   read(): T;
   write(): ShallowReadWrite<T>;
-  get<Path extends ReadonlyArray<PropertyKey>>(...path: Path): NestedContext<T, R, ParentContext, Path>;
+  get<Path extends ReadonlyArray<PropertyKey>>(...path: Path): NestedContext<T, ParentContext, Path>;
   set<Path extends ReadonlyArray<PropertyKey>>(...args: [...Path, NestedProp<T, Path>]): this;
-  update<Path extends ReadonlyArray<PropertyKey>>(...args: [...Path, (childContext: NestedContext<T, R, ParentContext, Path>) => unknown]): this;
+  update<Path extends ReadonlyArray<PropertyKey>>(...args: [...Path, (childContext: NestedContext<T, ParentContext, Path>) => unknown]): this;
   parent(): ParentContext;
-  root(): CowRootContext<R>;
+  root(): GetCowContextRoot<this>;
   revoke(): void;
   isRevoked(): boolean;
   final(): T;
-  finalRoot(): R;
+  finalRoot(): GetCowContextSource<GetCowContextRoot<this>>;
 }
 
-declare function mutate<T extends object>(
+declare function mutate<T>(
   source: T,
 ): CowRootContext<T>;
 

package/bench.mjs

@@ -1,74 +0,0 @@
-/*
- * Copyright (c) 2023 Michael Wiencek
- *
- * This source code is licensed under the MIT license. A copy can be found
- * in the file named "LICENSE" at the root directory of this distribution.
- */
-
-import Benchmark from 'benchmark';
-import mutate from './index.mjs';
-
-const root = {};
-for (let i = 65, next = root; i <= 90; i++) {
-  next = next[String.fromCharCode(i)] = {
-    prop1: 1,
-    prop2: 2,
-    prop3: 3,
-    prop4: 4,
-    prop5: 5,
-  };
-}
-
-const updater1 = () => {
-  mutate(root).set('root', true).final();
-};
-
-const updater2 = () => {
-  mutate(root)
-    .set(
-      'A',
-      'B',
-      'C',
-      'D',
-      'E',
-      'F',
-      'G',
-      'H',
-      'I',
-      'J',
-      'K',
-      'L',
-      'M',
-      'N',
-      'O',
-      'P',
-      'Q',
-      'R',
-      'S',
-      'T',
-      'U',
-      'V',
-      'W',
-      'X',
-      'Y',
-      'Z',
-      'leaf',
-      true,
-    )
-    .final();
-};
-
-function test() {
-  updater1(); // shallow update
-  updater2(); // deep update
-}
-
-new Benchmark.Suite()
-  .add('test', test)
-  .on('cycle', function (event) {
-    console.log(String(event.target));
-  })
-  .on('complete', function () {
-    console.log('Fastest is ' + this.filter('fastest').map('name'));
-  })
-  .run({async: true});

package/canClone.mjs

@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2023 Michael Wiencek
- *
- * This source code is licensed under the MIT license. A copy can be found
- * in the file named "LICENSE" at the root directory of this distribution.
- */
-
-const funcToString = Function.prototype.toString;
-
-const nativeCodeRegExp = /^function \w*\(\) \{\s*\[native code\]\s*\}$/m;
-
-export const CANNOT_CLONE_ERROR =
-  'Only plain objects, arrays, and class instances ' +
-  'can be cloned. Primitives, functions, and built-ins ' +
-  'are unsupported.';
-
-export default function canClone(object) {
-  if (!object || typeof object !== 'object') {
-    throw new Error(CANNOT_CLONE_ERROR);
-  }
-
-  let proto = Reflect.getPrototypeOf(object);
-
-  while (proto) {
-    let ctor = proto.constructor;
-    // A Generator object's constructor is an object.
-    if (ctor && typeof ctor === 'object') {
-      ctor = ctor.constructor;
-    }
-
-    if (typeof ctor === 'function' &&
-        ctor.name !== 'Array' &&
-        ctor.name !== 'Object' &&
-        nativeCodeRegExp.test(funcToString.call(ctor))) {
-      throw new Error(CANNOT_CLONE_ERROR);
-    }
-
-    proto = Reflect.getPrototypeOf(proto);
-  }
-}