fix(array): update

Author: unadlib

src/draft.ts

@@ -34,25 +34,15 @@ import {
 import { checkReadable } from './unsafe';
 import { generatePatches } from './patch';
 
-const draftsCache = new WeakSet<object>();
-
-let arrayHandling = false;
-
 // The array methods that need to be handled by the draft.
 // `sort` is not included, because array items may be modified by mutations in the sort function, it has to be drafted.
-const proxyArrayMethods = [
-  'splice',
-  'shift',
-  'unshift',
-  'reverse',
-  'copyWithin',
-];
+const proxyArrayMethods = ['splice', 'shift', 'unshift', 'reverse'];
 
 const proxyHandler: ProxyHandler<ProxyDraft> = {
   get(target: ProxyDraft, key: string | number | symbol, receiver: any) {
     const copy = target.copy?.[key];
     // Improve draft reading performance by caching the draft copy.
-    if (copy && draftsCache.has(copy)) {
+    if (copy && target.finalities.draftsCache.has(copy)) {
       return copy;
     }
     if (key === PROXY_DRAFT) return target;
@@ -74,6 +64,15 @@ const proxyHandler: ProxyHandler<ProxyDraft> = {
       }
     }
     const source = latest(target);
+    const skipFinalization = target.options.skipFinalization;
+
+    if (
+      skipFinalization &&
+      source[key] &&
+      target.finalities.draftsCache.has(source[key])
+    ) {
+      return source[key];
+    }
 
     if (source instanceof Map && mapHandlerKeys.includes(key as any)) {
       if (key === 'size') {
@@ -99,8 +98,6 @@ const proxyHandler: ProxyHandler<ProxyDraft> = {
       }
     }
 
-    const skipFinalization = target.options.skipFinalization;
-
     if (!has(source, key)) {
       const desc = getDescriptor(source, key);
       const value = desc?.value;
@@ -111,21 +108,21 @@ const proxyHandler: ProxyHandler<ProxyDraft> = {
       ) {
         return function (this: any, ...args: any[]) {
           let returnValue: any;
-          arrayHandling = true;
+          target.finalities.arrayHandling = true;
           try {
             returnValue = value.apply(this, args);
             if (isDraftable(returnValue, target.options)) {
               returnValue = createDraft({
                 original: returnValue,
-                parentDraft: target,
+                parentDraft: undefined,
                 key: undefined,
                 finalities: target.finalities,
                 options: target.options,
               });
             }
             return returnValue;
           } finally {
-            arrayHandling = false;
+            target.finalities.arrayHandling = false;
           }
         };
       }
@@ -145,7 +142,7 @@ const proxyHandler: ProxyHandler<ProxyDraft> = {
     }
     // Ensure that the assigned values are not drafted
     if (
-      !arrayHandling &&
+      !target.finalities.arrayHandling &&
       (value === peek(target.original, key) || skipFinalization?.has(value))
     ) {
       const shouldSkip = skipFinalization?.has(value);
@@ -171,12 +168,12 @@ const proxyHandler: ProxyHandler<ProxyDraft> = {
       return target.copy![key];
     }
     if (
-      arrayHandling &&
+      target.finalities.arrayHandling &&
       skipFinalization &&
       !isDraft(value) &&
       isDraftable(value)
     ) {
-      // !case: handle the case of assigning the original array item via array methods(`splice`, `shift``, `unshift`, `reverse`, `copyWithin`)
+      // !case: handle the case of assigning the original array item via array methods(`splice`, `shift``, `unshift`, `reverse`)
       skipFinalization.add(value);
     }
     return value;
@@ -313,7 +310,7 @@ export function createDraft<T extends object>(createDraftOptions: {
     proxyHandler
   );
   finalities.revoke.push(revoke);
-  draftsCache.add(proxy);
+  finalities.draftsCache.add(proxy);
   proxyDraft.proxy = proxy;
   if (parentDraft) {
     const target = parentDraft;

src/draftify.ts

@@ -21,6 +21,8 @@ export function draftify<
     draft: [],
     revoke: [],
     handledSet: new WeakSet<any>(),
+    draftsCache: new WeakSet<object>(),
+    arrayHandling: false,
   };
   let patches: Patches | undefined;
   let inversePatches: Patches | undefined;

src/interface.ts

@@ -32,6 +32,8 @@ export interface Finalities {
   draft: ((patches?: Patches, inversePatches?: Patches) => void)[];
   revoke: (() => void)[];
   handledSet: WeakSet<any>;
+  draftsCache: WeakSet<object>;
+  arrayHandling: boolean;
 }
 
 export interface ProxyDraft<T = any> {