@tanstack/db 0.5.5 → 0.5.7

package/dist/esm/proxy.js

@@ -1,4 +1,259 @@
 import { isTemporal, deepEquals } from "./utils.js";
+const CALLBACK_ITERATION_METHODS = /* @__PURE__ */ new Set([
+  `find`,
+  `findLast`,
+  `findIndex`,
+  `findLastIndex`,
+  `filter`,
+  `map`,
+  `flatMap`,
+  `forEach`,
+  `some`,
+  `every`,
+  `reduce`,
+  `reduceRight`
+]);
+const ARRAY_MODIFYING_METHODS = /* @__PURE__ */ new Set([
+  `pop`,
+  `push`,
+  `shift`,
+  `unshift`,
+  `splice`,
+  `sort`,
+  `reverse`,
+  `fill`,
+  `copyWithin`
+]);
+const MAP_SET_MODIFYING_METHODS = /* @__PURE__ */ new Set([`set`, `delete`, `clear`, `add`]);
+const MAP_SET_ITERATOR_METHODS = /* @__PURE__ */ new Set([
+  `entries`,
+  `keys`,
+  `values`,
+  `forEach`
+]);
+function isProxiableObject(value) {
+  return value !== null && typeof value === `object` && !(value instanceof Date) && !(value instanceof RegExp) && !isTemporal(value);
+}
+function createArrayIterationHandler(methodName, methodFn, changeTracker, memoizedCreateChangeProxy) {
+  if (!CALLBACK_ITERATION_METHODS.has(methodName)) {
+    return void 0;
+  }
+  return function(...args) {
+    const callback = args[0];
+    if (typeof callback !== `function`) {
+      return methodFn.apply(changeTracker.copy_, args);
+    }
+    const getProxiedElement = (element, index) => {
+      if (isProxiableObject(element)) {
+        const nestedParent = {
+          tracker: changeTracker,
+          prop: String(index)
+        };
+        const { proxy: elementProxy } = memoizedCreateChangeProxy(
+          element,
+          nestedParent
+        );
+        return elementProxy;
+      }
+      return element;
+    };
+    const wrappedCallback = function(element, index, array) {
+      const proxiedElement = getProxiedElement(element, index);
+      return callback.call(this, proxiedElement, index, array);
+    };
+    if (methodName === `reduce` || methodName === `reduceRight`) {
+      const reduceCallback = function(accumulator, element, index, array) {
+        const proxiedElement = getProxiedElement(element, index);
+        return callback.call(this, accumulator, proxiedElement, index, array);
+      };
+      return methodFn.apply(changeTracker.copy_, [
+        reduceCallback,
+        ...args.slice(1)
+      ]);
+    }
+    const result = methodFn.apply(changeTracker.copy_, [
+      wrappedCallback,
+      ...args.slice(1)
+    ]);
+    if ((methodName === `find` || methodName === `findLast`) && result && typeof result === `object`) {
+      const foundIndex = changeTracker.copy_.indexOf(result);
+      if (foundIndex !== -1) {
+        return getProxiedElement(result, foundIndex);
+      }
+    }
+    if (methodName === `filter` && Array.isArray(result)) {
+      return result.map((element) => {
+        const originalIndex = changeTracker.copy_.indexOf(element);
+        if (originalIndex !== -1) {
+          return getProxiedElement(element, originalIndex);
+        }
+        return element;
+      });
+    }
+    return result;
+  };
+}
+function createArrayIteratorHandler(changeTracker, memoizedCreateChangeProxy) {
+  return function() {
+    const array = changeTracker.copy_;
+    let index = 0;
+    return {
+      next() {
+        if (index >= array.length) {
+          return { done: true, value: void 0 };
+        }
+        const element = array[index];
+        let proxiedElement = element;
+        if (isProxiableObject(element)) {
+          const nestedParent = {
+            tracker: changeTracker,
+            prop: String(index)
+          };
+          const { proxy: elementProxy } = memoizedCreateChangeProxy(
+            element,
+            nestedParent
+          );
+          proxiedElement = elementProxy;
+        }
+        index++;
+        return { done: false, value: proxiedElement };
+      },
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function createModifyingMethodHandler(methodFn, changeTracker, markChanged) {
+  return function(...args) {
+    const result = methodFn.apply(changeTracker.copy_, args);
+    markChanged(changeTracker);
+    return result;
+  };
+}
+function createMapSetIteratorHandler(methodName, prop, methodFn, target, changeTracker, memoizedCreateChangeProxy, markChanged) {
+  const isIteratorMethod = MAP_SET_ITERATOR_METHODS.has(methodName) || prop === Symbol.iterator;
+  if (!isIteratorMethod) {
+    return void 0;
+  }
+  return function(...args) {
+    const result = methodFn.apply(changeTracker.copy_, args);
+    if (methodName === `forEach`) {
+      const callback = args[0];
+      if (typeof callback === `function`) {
+        const wrappedCallback = function(value, key, collection) {
+          const cbresult = callback.call(this, value, key, collection);
+          markChanged(changeTracker);
+          return cbresult;
+        };
+        return methodFn.apply(target, [wrappedCallback, ...args.slice(1)]);
+      }
+    }
+    const isValueIterator = methodName === `entries` || methodName === `values` || methodName === Symbol.iterator.toString() || prop === Symbol.iterator;
+    if (isValueIterator) {
+      const originalIterator = result;
+      const valueToKeyMap = /* @__PURE__ */ new Map();
+      if (methodName === `values` && target instanceof Map) {
+        for (const [key, mapValue] of changeTracker.copy_.entries()) {
+          valueToKeyMap.set(mapValue, key);
+        }
+      }
+      const originalToModifiedMap = /* @__PURE__ */ new Map();
+      if (target instanceof Set) {
+        for (const setValue of changeTracker.copy_.values()) {
+          originalToModifiedMap.set(setValue, setValue);
+        }
+      }
+      return {
+        next() {
+          const nextResult = originalIterator.next();
+          if (!nextResult.done && nextResult.value && typeof nextResult.value === `object`) {
+            if (methodName === `entries` && Array.isArray(nextResult.value) && nextResult.value.length === 2) {
+              if (nextResult.value[1] && typeof nextResult.value[1] === `object`) {
+                const mapKey = nextResult.value[0];
+                const mapParent = {
+                  tracker: changeTracker,
+                  prop: mapKey,
+                  updateMap: (newValue) => {
+                    if (changeTracker.copy_ instanceof Map) {
+                      changeTracker.copy_.set(
+                        mapKey,
+                        newValue
+                      );
+                    }
+                  }
+                };
+                const { proxy: valueProxy } = memoizedCreateChangeProxy(
+                  nextResult.value[1],
+                  mapParent
+                );
+                nextResult.value[1] = valueProxy;
+              }
+            } else if (methodName === `values` || methodName === Symbol.iterator.toString() || prop === Symbol.iterator) {
+              if (methodName === `values` && target instanceof Map) {
+                const mapKey = valueToKeyMap.get(nextResult.value);
+                if (mapKey !== void 0) {
+                  const mapParent = {
+                    tracker: changeTracker,
+                    prop: mapKey,
+                    updateMap: (newValue) => {
+                      if (changeTracker.copy_ instanceof Map) {
+                        changeTracker.copy_.set(
+                          mapKey,
+                          newValue
+                        );
+                      }
+                    }
+                  };
+                  const { proxy: valueProxy } = memoizedCreateChangeProxy(
+                    nextResult.value,
+                    mapParent
+                  );
+                  nextResult.value = valueProxy;
+                }
+              } else if (target instanceof Set) {
+                const setOriginalValue = nextResult.value;
+                const setParent = {
+                  tracker: changeTracker,
+                  prop: setOriginalValue,
+                  updateSet: (newValue) => {
+                    if (changeTracker.copy_ instanceof Set) {
+                      changeTracker.copy_.delete(
+                        setOriginalValue
+                      );
+                      changeTracker.copy_.add(newValue);
+                      originalToModifiedMap.set(setOriginalValue, newValue);
+                    }
+                  }
+                };
+                const { proxy: valueProxy } = memoizedCreateChangeProxy(
+                  nextResult.value,
+                  setParent
+                );
+                nextResult.value = valueProxy;
+              } else {
+                const tempKey = Symbol(`iterator-value`);
+                const { proxy: valueProxy } = memoizedCreateChangeProxy(
+                  nextResult.value,
+                  {
+                    tracker: changeTracker,
+                    prop: tempKey
+                  }
+                );
+                nextResult.value = valueProxy;
+              }
+            }
+          }
+          return nextResult;
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+    }
+    return result;
+  };
+}
 function debugLog(...args) {
   const isBrowser = typeof window !== `undefined` && typeof localStorage !== `undefined`;
   if (isBrowser && localStorage.getItem(`DEBUG`) === `true`) {
@@ -211,182 +466,54 @@ function createChangeProxy(target, parent) {
         if (typeof value === `function`) {
           if (Array.isArray(ptarget)) {
             const methodName = prop.toString();
-            const modifyingMethods = /* @__PURE__ */ new Set([
-              `pop`,
-              `push`,
-              `shift`,
-              `unshift`,
-              `splice`,
-              `sort`,
-              `reverse`,
-              `fill`,
-              `copyWithin`
-            ]);
-            if (modifyingMethods.has(methodName)) {
-              return function(...args) {
-                const result = value.apply(changeTracker.copy_, args);
-                markChanged(changeTracker);
-                return result;
-              };
+            if (ARRAY_MODIFYING_METHODS.has(methodName)) {
+              return createModifyingMethodHandler(
+                value,
+                changeTracker,
+                markChanged
+              );
+            }
+            const iterationHandler = createArrayIterationHandler(
+              methodName,
+              value,
+              changeTracker,
+              memoizedCreateChangeProxy
+            );
+            if (iterationHandler) {
+              return iterationHandler;
+            }
+            if (prop === Symbol.iterator) {
+              return createArrayIteratorHandler(
+                changeTracker,
+                memoizedCreateChangeProxy
+              );
             }
           }
           if (ptarget instanceof Map || ptarget instanceof Set) {
             const methodName = prop.toString();
-            const modifyingMethods = /* @__PURE__ */ new Set([
-              `set`,
-              `delete`,
-              `clear`,
-              `add`,
-              `pop`,
-              `push`,
-              `shift`,
-              `unshift`,
-              `splice`,
-              `sort`,
-              `reverse`
-            ]);
-            if (modifyingMethods.has(methodName)) {
-              return function(...args) {
-                const result = value.apply(changeTracker.copy_, args);
-                markChanged(changeTracker);
-                return result;
-              };
+            if (MAP_SET_MODIFYING_METHODS.has(methodName)) {
+              return createModifyingMethodHandler(
+                value,
+                changeTracker,
+                markChanged
+              );
             }
-            const iteratorMethods = /* @__PURE__ */ new Set([
-              `entries`,
-              `keys`,
-              `values`,
-              `forEach`,
-              Symbol.iterator
-            ]);
-            if (iteratorMethods.has(methodName) || prop === Symbol.iterator) {
-              return function(...args) {
-                const result = value.apply(changeTracker.copy_, args);
-                if (methodName === `forEach`) {
-                  const callback = args[0];
-                  if (typeof callback === `function`) {
-                    const wrappedCallback = function(value2, key, collection) {
-                      const cbresult = callback.call(
-                        this,
-                        value2,
-                        key,
-                        collection
-                      );
-                      markChanged(changeTracker);
-                      return cbresult;
-                    };
-                    return value.apply(ptarget, [
-                      wrappedCallback,
-                      ...args.slice(1)
-                    ]);
-                  }
-                }
-                if (methodName === `entries` || methodName === `values` || methodName === Symbol.iterator.toString() || prop === Symbol.iterator) {
-                  const originalIterator = result;
-                  const valueToKeyMap = /* @__PURE__ */ new Map();
-                  if (methodName === `values` && ptarget instanceof Map) {
-                    for (const [
-                      key,
-                      mapValue
-                    ] of changeTracker.copy_.entries()) {
-                      valueToKeyMap.set(mapValue, key);
-                    }
-                  }
-                  const originalToModifiedMap = /* @__PURE__ */ new Map();
-                  if (ptarget instanceof Set) {
-                    for (const setValue of changeTracker.copy_.values()) {
-                      originalToModifiedMap.set(setValue, setValue);
-                    }
-                  }
-                  return {
-                    next() {
-                      const nextResult = originalIterator.next();
-                      if (!nextResult.done && nextResult.value && typeof nextResult.value === `object`) {
-                        if (methodName === `entries` && Array.isArray(nextResult.value) && nextResult.value.length === 2) {
-                          if (nextResult.value[1] && typeof nextResult.value[1] === `object`) {
-                            const mapKey = nextResult.value[0];
-                            const mapParent = {
-                              tracker: changeTracker,
-                              prop: mapKey,
-                              updateMap: (newValue) => {
-                                if (changeTracker.copy_ instanceof Map) {
-                                  changeTracker.copy_.set(mapKey, newValue);
-                                }
-                              }
-                            };
-                            const { proxy: valueProxy } = memoizedCreateChangeProxy(
-                              nextResult.value[1],
-                              mapParent
-                            );
-                            nextResult.value[1] = valueProxy;
-                          }
-                        } else if (methodName === `values` || methodName === Symbol.iterator.toString() || prop === Symbol.iterator) {
-                          if (typeof nextResult.value === `object` && nextResult.value !== null) {
-                            if (methodName === `values` && ptarget instanceof Map) {
-                              const mapKey = valueToKeyMap.get(nextResult.value);
-                              if (mapKey !== void 0) {
-                                const mapParent = {
-                                  tracker: changeTracker,
-                                  prop: mapKey,
-                                  updateMap: (newValue) => {
-                                    if (changeTracker.copy_ instanceof Map) {
-                                      changeTracker.copy_.set(mapKey, newValue);
-                                    }
-                                  }
-                                };
-                                const { proxy: valueProxy } = memoizedCreateChangeProxy(
-                                  nextResult.value,
-                                  mapParent
-                                );
-                                nextResult.value = valueProxy;
-                              }
-                            } else if (ptarget instanceof Set) {
-                              const setOriginalValue = nextResult.value;
-                              const setParent = {
-                                tracker: changeTracker,
-                                prop: setOriginalValue,
-                                // Use the original value as the prop
-                                updateSet: (newValue) => {
-                                  if (changeTracker.copy_ instanceof Set) {
-                                    changeTracker.copy_.delete(setOriginalValue);
-                                    changeTracker.copy_.add(newValue);
-                                    originalToModifiedMap.set(
-                                      setOriginalValue,
-                                      newValue
-                                    );
-                                  }
-                                }
-                              };
-                              const { proxy: valueProxy } = memoizedCreateChangeProxy(
-                                nextResult.value,
-                                setParent
-                              );
-                              nextResult.value = valueProxy;
-                            } else {
-                              const tempKey = Symbol(`iterator-value`);
-                              const { proxy: valueProxy } = memoizedCreateChangeProxy(nextResult.value, {
-                                tracker: changeTracker,
-                                prop: tempKey
-                              });
-                              nextResult.value = valueProxy;
-                            }
-                          }
-                        }
-                      }
-                      return nextResult;
-                    },
-                    [Symbol.iterator]() {
-                      return this;
-                    }
-                  };
-                }
-                return result;
-              };
+            const iteratorHandler = createMapSetIteratorHandler(
+              methodName,
+              prop,
+              value,
+              ptarget,
+              changeTracker,
+              memoizedCreateChangeProxy,
+              markChanged
+            );
+            if (iteratorHandler) {
+              return iteratorHandler;
             }
           }
           return value.bind(ptarget);
         }
-        if (value && typeof value === `object` && !(value instanceof Date) && !(value instanceof RegExp) && !isTemporal(value)) {
+        if (isProxiableObject(value)) {
           const nestedParent = {
             tracker: changeTracker,
             prop: String(prop)