@tanstack/db 0.0.4 → 0.0.5

package/dist/cjs/collection.d.cts

@@ -2,6 +2,14 @@ import { Derived, Store } from '@tanstack/store';
 import { SortedMap } from './SortedMap.cjs';
 import { ChangeMessage, CollectionConfig, InsertConfig, OperationConfig, OptimisticChangeMessage, Transaction } from './types.cjs';
 export declare const collectionsStore: Store<Map<string, Collection<any>>, (cb: Map<string, Collection<any>>) => Map<string, Collection<any>>>;
+/**
+ * Creates a new Collection instance with the given configuration
+ *
+ * @template T - The type of items in the collection
+ * @param config - Configuration for the collection, including id and sync
+ * @returns A new Collection instance
+ */
+export declare function createCollection<T extends object = Record<string, unknown>>(config: CollectionConfig<T>): Collection<T>;
 /**
  * Preloads a collection with the given configuration
  * Returns a promise that resolves once the sync tool has done its first commit (initial sync is finished)
@@ -55,7 +63,6 @@ export declare class Collection<T extends object = Record<string, unknown>> {
     private syncedKeys;
     config: CollectionConfig<T>;
     private hasReceivedFirstCommit;
-    objectKeyMap: WeakMap<object, string>;
     private onFirstCommitCallbacks;
     /**
      * Register a callback to be executed on the next commit
@@ -63,22 +70,23 @@ export declare class Collection<T extends object = Record<string, unknown>> {
      * @param callback Function to call after the next commit
      */
     onFirstCommit(callback: () => void): void;
-    id: `${string}-${string}-${string}-${string}-${string}`;
+    id: string;
     /**
      * Creates a new Collection instance
      *
      * @param config - Configuration object for the collection
      * @throws Error if sync config is missing
      */
-    constructor(config?: CollectionConfig<T>);
+    constructor(config: CollectionConfig<T>);
     /**
      * Attempts to commit pending synced transactions if there are no active transactions
      * This method processes operations from pending transactions and applies them to the synced data
      */
     commitPendingTransactions: () => void;
     private ensureStandardSchema;
+    private getKeyFromId;
+    generateObjectKey(id: any, item: any): string;
     private validateData;
-    private generateKey;
     /**
      * Inserts one or more items into the collection
      * @param items - Single item or array of items to insert
@@ -118,24 +126,43 @@ export declare class Collection<T extends object = Record<string, unknown>> {
      * // Update with metadata
      * update(todo, { metadata: { reason: "user update" } }, (draft) => { draft.text = "Updated text" })
      */
-    update<TItem extends object = T>(item: TItem, configOrCallback: ((draft: TItem) => void) | OperationConfig, maybeCallback?: (draft: TItem) => void): Transaction;
-    update<TItem extends object = T>(items: Array<TItem>, configOrCallback: ((draft: Array<TItem>) => void) | OperationConfig, maybeCallback?: (draft: Array<TItem>) => void): Transaction;
+    /**
+     * Updates one or more items in the collection using a callback function
+     * @param ids - Single ID or array of IDs to update
+     * @param configOrCallback - Either update configuration or update callback
+     * @param maybeCallback - Update callback if config was provided
+     * @returns A Transaction object representing the update operation(s)
+     * @throws {SchemaValidationError} If the updated data fails schema validation
+     * @example
+     * // Update a single item
+     * update("todo-1", (draft) => { draft.completed = true })
+     *
+     * // Update multiple items
+     * update(["todo-1", "todo-2"], (drafts) => {
+     *   drafts.forEach(draft => { draft.completed = true })
+     * })
+     *
+     * // Update with metadata
+     * update("todo-1", { metadata: { reason: "user update" } }, (draft) => { draft.text = "Updated text" })
+     */
+    update<TItem extends object = T>(id: unknown, configOrCallback: ((draft: TItem) => void) | OperationConfig, maybeCallback?: (draft: TItem) => void): Transaction;
+    update<TItem extends object = T>(ids: Array<unknown>, configOrCallback: ((draft: Array<TItem>) => void) | OperationConfig, maybeCallback?: (draft: Array<TItem>) => void): Transaction;
     /**
      * Deletes one or more items from the collection
-     * @param items - Single item/key or array of items/keys to delete
+     * @param ids - Single ID or array of IDs to delete
      * @param config - Optional configuration including metadata
      * @returns A Transaction object representing the delete operation(s)
      * @example
      * // Delete a single item
-     * delete(todo)
+     * delete("todo-1")
      *
      * // Delete multiple items
-     * delete([todo1, todo2])
+     * delete(["todo-1", "todo-2"])
      *
      * // Delete with metadata
-     * delete(todo, { metadata: { reason: "completed" } })
+     * delete("todo-1", { metadata: { reason: "completed" } })
      */
-    delete: (items: Array<T | string> | T | string, config?: OperationConfig) => Transaction;
+    delete: (ids: Array<string> | string, config?: OperationConfig) => Transaction;
     /**
      * Gets the current state of the collection as a Map
      *

package/dist/cjs/index.cjs

@@ -12,6 +12,7 @@ const pipelineCompiler = require("./query/pipeline-compiler.cjs");
 exports.Collection = collection.Collection;
 exports.SchemaValidationError = collection.SchemaValidationError;
 exports.collectionsStore = collection.collectionsStore;
+exports.createCollection = collection.createCollection;
 exports.preloadCollection = collection.preloadCollection;
 exports.SortedMap = SortedMap.SortedMap;
 exports.Transaction = transactions.Transaction;

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/proxy.cjs

@@ -4,7 +4,10 @@ function debugLog(...args) {
   const isBrowser = typeof window !== `undefined` && typeof localStorage !== `undefined`;
   if (isBrowser && localStorage.getItem(`DEBUG`) === `true`) {
     console.log(`[proxy]`, ...args);
-  } else if (!isBrowser && typeof process !== `undefined` && process.env.DEBUG === `true`) {
+  } else if (
+    // true
+    !isBrowser && typeof process !== `undefined` && process.env.DEBUG === `true`
+  ) {
     console.log(`[proxy]`, ...args);
   }
 }
@@ -131,24 +134,48 @@ function deepEqual(a, b) {
     (key) => Object.prototype.hasOwnProperty.call(b, key) && deepEqual(a[key], b[key])
   );
 }
+let count = 0;
+function getProxyCount() {
+  count += 1;
+  return count;
+}
 function createChangeProxy(target, parent) {
-  const proxyCache = /* @__PURE__ */ new WeakMap();
+  const changeProxyCache = /* @__PURE__ */ new Map();
+  function memoizedCreateChangeProxy(innerTarget, innerParent) {
+    debugLog(`Object ID:`, innerTarget.constructor.name);
+    if (changeProxyCache.has(innerTarget)) {
+      return changeProxyCache.get(innerTarget);
+    } else {
+      const changeProxy = createChangeProxy(innerTarget, innerParent);
+      changeProxyCache.set(innerTarget, changeProxy);
+      return changeProxy;
+    }
+  }
+  const proxyCache = /* @__PURE__ */ new Map();
   const changeTracker = {
-    changes: {},
+    copy_: deepClone(target),
     originalObject: deepClone(target),
-    // Create a deep clone to preserve the original state
+    proxyCount: getProxyCount(),
     modified: false,
     assigned_: {},
     parent,
     target
     // Store reference to the target object
   };
+  debugLog(
+    `createChangeProxy called for target`,
+    target,
+    changeTracker.proxyCount
+  );
   function markChanged(state) {
     if (!state.modified) {
       state.modified = true;
-      if (state.parent) {
-        markChanged(state.parent.tracker);
-      }
+    }
+    if (state.parent) {
+      debugLog(`propagating change to parent`);
+      state.parent.tracker.copy_[state.parent.prop] = state.copy_;
+      state.parent.tracker.assigned_[state.parent.prop] = true;
+      markChanged(state.parent.tracker);
     }
   }
   function checkIfReverted(state) {
@@ -162,7 +189,7 @@ function createChangeProxy(target, parent) {
     }
     for (const prop in state.assigned_) {
       if (state.assigned_[prop] === true) {
-        const currentValue = state.copy_ ? state.copy_[prop] : null;
+        const currentValue = state.copy_[prop];
         const originalValue = state.originalObject[prop];
         debugLog(
           `Checking property ${String(prop)}, current:`,
@@ -181,14 +208,14 @@ function createChangeProxy(target, parent) {
     }
     const symbolProps = Object.getOwnPropertySymbols(state.assigned_);
     for (const sym of symbolProps) {
-      if (state.assigned_[sym.toString()] === true) {
-        const currentValue = state.copy_ ? state.copy_[sym] : null;
+      if (state.assigned_[sym] === true) {
+        const currentValue = state.copy_[sym];
         const originalValue = state.originalObject[sym];
         if (!deepEqual(currentValue, originalValue)) {
           debugLog(`Symbol property is different, returning false`);
           return false;
         }
-      } else if (state.assigned_[sym.toString()] === false) {
+      } else if (state.assigned_[sym] === false) {
         debugLog(`Symbol property was deleted, returning false`);
         return false;
       }
@@ -196,31 +223,6 @@ function createChangeProxy(target, parent) {
     debugLog(`All properties match original values, returning true`);
     return true;
   }
-  function updateModifiedStatus(state) {
-    debugLog(
-      `updateModifiedStatus called, assigned keys:`,
-      Object.keys(state.assigned_)
-    );
-    if (Object.keys(state.assigned_).length === 0 && Object.getOwnPropertySymbols(state.assigned_).length === 0) {
-      debugLog(`No assigned properties, returning false`);
-      return false;
-    }
-    const isReverted = checkIfReverted(state);
-    debugLog(`checkIfReverted returned:`, isReverted);
-    if (!isReverted) {
-      debugLog(`Object has changes that aren't reverted, returning true`);
-      return true;
-    }
-    debugLog(`All changes reverted, clearing tracking`);
-    state.modified = false;
-    state.changes = {};
-    state.assigned_ = {};
-    if (state.parent) {
-      debugLog(`Checking parent status for prop:`, state.parent.prop);
-      checkParentStatus(state.parent.tracker, state.parent.prop);
-    }
-    return false;
-  }
   function checkParentStatus(parentState, childProp) {
     debugLog(`checkParentStatus called for child prop:`, childProp);
     const isReverted = checkIfReverted(parentState);
@@ -228,7 +230,6 @@ function createChangeProxy(target, parent) {
     if (isReverted) {
       debugLog(`Parent is fully reverted, clearing tracking`);
       parentState.modified = false;
-      parentState.changes = {};
       parentState.assigned_ = {};
       if (parentState.parent) {
         debugLog(`Continuing up the parent chain`);
@@ -237,12 +238,17 @@ function createChangeProxy(target, parent) {
     }
   }
   function createObjectProxy(obj) {
+    debugLog(`createObjectProxy`, obj);
     if (proxyCache.has(obj)) {
+      debugLog(`proxyCache found match`);
       return proxyCache.get(obj);
     }
     const proxy2 = new Proxy(obj, {
       get(ptarget, prop) {
-        const value = ptarget[prop];
+        debugLog(`get`, ptarget, prop);
+        const value = changeTracker.copy_[prop] ?? changeTracker.originalObject[prop];
+        const originalValue = changeTracker.originalObject[prop];
+        debugLog(`value (at top of proxy get)`, value);
         const desc = Object.getOwnPropertyDescriptor(ptarget, prop);
         if (desc == null ? void 0 : desc.get) {
           return value;
@@ -265,7 +271,7 @@ function createChangeProxy(target, parent) {
             ]);
             if (modifyingMethods.has(methodName)) {
               return function(...args) {
-                const result = value.apply(ptarget, args);
+                const result = value.apply(changeTracker.copy_, args);
                 markChanged(changeTracker);
                 return result;
               };
@@ -279,7 +285,7 @@ function createChangeProxy(target, parent) {
             ]);
             if (iteratorMethods.has(methodName) || prop === Symbol.iterator) {
               return function(...args) {
-                const result = value.apply(ptarget, args);
+                const result = value.apply(changeTracker.copy_, args);
                 if (methodName === `forEach`) {
                   const callback = args[0];
                   if (typeof callback === `function`) {
@@ -307,25 +313,19 @@ function createChangeProxy(target, parent) {
                       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 { proxy: valueProxy } = createChangeProxy(
-                              nextResult.value[1],
-                              {
-                                tracker: changeTracker,
-                                prop: typeof nextResult.value[0] === `symbol` ? nextResult.value[0] : String(nextResult.value[0])
-                              }
-                            );
+                            const { proxy: valueProxy } = memoizedCreateChangeProxy(nextResult.value[1], {
+                              tracker: changeTracker,
+                              prop: typeof nextResult.value[0] === `symbol` ? nextResult.value[0] : String(nextResult.value[0])
+                            });
                             nextResult.value[1] = valueProxy;
                           }
                         } else if (methodName === `values` || methodName === Symbol.iterator.toString() || prop === Symbol.iterator) {
                           if (typeof nextResult.value === `object` && nextResult.value !== null) {
                             const tempKey = Symbol(`iterator-value`);
-                            const { proxy: valueProxy } = createChangeProxy(
-                              nextResult.value,
-                              {
-                                tracker: changeTracker,
-                                prop: tempKey
-                              }
-                            );
+                            const { proxy: valueProxy } = memoizedCreateChangeProxy(nextResult.value, {
+                              tracker: changeTracker,
+                              prop: tempKey
+                            });
                             nextResult.value = valueProxy;
                           }
                         }
@@ -348,59 +348,45 @@ function createChangeProxy(target, parent) {
             tracker: changeTracker,
             prop: String(prop)
           };
-          const { proxy: nestedProxy } = createChangeProxy(value, nestedParent);
+          const { proxy: nestedProxy } = memoizedCreateChangeProxy(
+            originalValue,
+            nestedParent
+          );
           proxyCache.set(value, nestedProxy);
           return nestedProxy;
         }
         return value;
       },
       set(sobj, prop, value) {
-        const currentValue = sobj[prop];
+        const currentValue = changeTracker.copy_[prop];
         debugLog(
           `set called for property ${String(prop)}, current:`,
           currentValue,
           `new:`,
           value
         );
-        if (Array.isArray(sobj) && prop === `length`) {
-          const newLength = Number(value);
-          const oldLength = sobj.length;
-          const newArray = Array.from(
-            { length: newLength },
-            (_, i) => i < oldLength ? sobj[i] : void 0
-          );
-          if (parent) {
-            parent.tracker.changes[parent.prop] = newArray;
-            parent.tracker.assigned_[parent.prop] = true;
-            markChanged(parent.tracker);
-          }
-          sobj.length = newLength;
-          return true;
-        }
         if (!deepEqual(currentValue, value)) {
           const originalValue = changeTracker.originalObject[prop];
           const isRevertToOriginal = deepEqual(value, originalValue);
           debugLog(
-            `Value different, original:`,
+            `value:`,
+            value,
+            `original:`,
             originalValue,
             `isRevertToOriginal:`,
             isRevertToOriginal
           );
           if (isRevertToOriginal) {
             debugLog(`Reverting property ${String(prop)} to original value`);
-            delete changeTracker.changes[prop.toString()];
             delete changeTracker.assigned_[prop.toString()];
-            if (changeTracker.copy_) {
-              debugLog(`Updating copy with original value for ${String(prop)}`);
-              changeTracker.copy_[prop] = deepClone(originalValue);
-            }
+            debugLog(`Updating copy with original value for ${String(prop)}`);
+            changeTracker.copy_[prop] = deepClone(originalValue);
             debugLog(`Checking if all properties reverted`);
             const allReverted = checkIfReverted(changeTracker);
             debugLog(`All reverted:`, allReverted);
             if (allReverted) {
               debugLog(`All properties reverted, clearing tracking`);
               changeTracker.modified = false;
-              changeTracker.changes = {};
               changeTracker.assigned_ = {};
               if (parent) {
                 debugLog(`Updating parent for property:`, parent.prop);
@@ -412,14 +398,9 @@ function createChangeProxy(target, parent) {
             }
           } else {
             debugLog(`Setting new value for property ${String(prop)}`);
-            prepareCopy(changeTracker);
-            if (changeTracker.copy_) {
-              changeTracker.copy_[prop] = value;
-            }
-            obj[prop] = value;
+            changeTracker.copy_[prop] = value;
             changeTracker.assigned_[prop.toString()] = true;
-            changeTracker.changes[prop.toString()] = deepClone(value);
-            debugLog(`Marking object and ancestors as modified`);
+            debugLog(`Marking object and ancestors as modified`, changeTracker);
             markChanged(changeTracker);
           }
         } else {
@@ -428,30 +409,21 @@ function createChangeProxy(target, parent) {
         return true;
       },
       defineProperty(ptarget, prop, descriptor) {
-        const result = Reflect.defineProperty(ptarget, prop, descriptor);
-        if (result) {
-          if (`value` in descriptor) {
-            changeTracker.changes[prop.toString()] = deepClone(descriptor.value);
-            changeTracker.assigned_[prop.toString()] = true;
-            markChanged(changeTracker);
-          }
+        if (`value` in descriptor) {
+          changeTracker.copy_[prop] = deepClone(descriptor.value);
+          changeTracker.assigned_[prop.toString()] = true;
+          markChanged(changeTracker);
         }
-        return result;
-      },
-      setPrototypeOf(ptarget, proto) {
-        return Object.setPrototypeOf(ptarget, proto);
+        return true;
       },
       deleteProperty(dobj, prop) {
+        debugLog(`deleteProperty`, dobj, prop);
         const stringProp = typeof prop === `symbol` ? prop.toString() : prop;
         if (stringProp in dobj) {
           const hadPropertyInOriginal = stringProp in changeTracker.originalObject;
-          prepareCopy(changeTracker);
-          if (changeTracker.copy_) {
-            delete changeTracker.copy_[prop];
-          }
-          delete dobj[prop];
+          delete changeTracker.copy_[prop];
           if (!hadPropertyInOriginal) {
-            delete changeTracker.changes[stringProp];
+            delete changeTracker.copy_[stringProp];
             delete changeTracker.assigned_[stringProp];
             if (Object.keys(changeTracker.assigned_).length === 0 && Object.getOwnPropertySymbols(changeTracker.assigned_).length === 0) {
               changeTracker.modified = false;
@@ -460,7 +432,7 @@ function createChangeProxy(target, parent) {
             }
           } else {
             changeTracker.assigned_[stringProp] = false;
-            changeTracker.changes[stringProp] = void 0;
+            changeTracker.copy_[stringProp] = void 0;
             markChanged(changeTracker);
           }
         }
@@ -474,133 +446,26 @@ function createChangeProxy(target, parent) {
   return {
     proxy,
     getChanges: () => {
-      debugLog(
-        `getChanges called, modified:`,
-        changeTracker.modified,
-        `assigned keys:`,
-        Object.keys(changeTracker.assigned_)
-      );
+      debugLog(`getChanges called, modified:`, changeTracker.modified);
+      debugLog(changeTracker);
       if (!changeTracker.modified) {
         debugLog(`Object not modified, returning empty object`);
         return {};
       }
-      if (Object.keys(changeTracker.assigned_).length === 0 && Object.getOwnPropertySymbols(changeTracker.assigned_).length === 0) {
-        debugLog(`No assigned properties, checking deep equality`);
-        if (changeTracker.copy_) {
-          debugLog(`Comparing copy with original`);
-          if (deepEqual(changeTracker.copy_, changeTracker.originalObject)) {
-            debugLog(`Copy equals original, returning empty object`);
-            changeTracker.modified = false;
-            return {};
-          }
-        } else if (deepEqual(target, changeTracker.originalObject)) {
-          debugLog(`Target equals original, returning empty object`);
-          changeTracker.modified = false;
-          changeTracker.changes = {};
-          changeTracker.assigned_ = {};
-          return {};
-        }
+      if (typeof changeTracker.copy_ !== `object` || Array.isArray(changeTracker.copy_)) {
+        return changeTracker.copy_;
       }
-      debugLog(`Forcing full check for reverted state`);
-      updateModifiedStatus(changeTracker);
-      if (!changeTracker.modified) {
-        debugLog(`No longer modified after check, returning empty object`);
-        return {};
+      if (Object.keys(changeTracker.assigned_).length === 0) {
+        return changeTracker.copy_;
       }
-      if (changeTracker.modified) {
-        const objToCheck = changeTracker.copy_ || target;
-        debugLog(
-          `Checking if object is equal to original:`,
-          objToCheck,
-          changeTracker.originalObject
-        );
-        if (deepEqual(objToCheck, changeTracker.originalObject)) {
-          debugLog(`Object equals original, returning empty object`);
-          changeTracker.modified = false;
-          changeTracker.changes = {};
-          changeTracker.assigned_ = {};
-          return {};
+      const result = {};
+      for (const key in changeTracker.copy_) {
+        if (changeTracker.assigned_[key] === true && key in changeTracker.copy_) {
+          result[key] = changeTracker.copy_[key];
         }
       }
-      if (Object.keys(changeTracker.assigned_).length > 0 || Object.getOwnPropertySymbols(changeTracker.assigned_).length > 0) {
-        if (changeTracker.copy_) {
-          const changes = {};
-          for (const key in changeTracker.assigned_) {
-            if (changeTracker.assigned_[key] === true) {
-              changes[key] = deepClone(changeTracker.copy_[key]);
-            } else if (changeTracker.assigned_[key] === false) {
-              changes[key] = void 0;
-            }
-          }
-          const symbolProps = Object.getOwnPropertySymbols(
-            changeTracker.assigned_
-          );
-          for (const sym of symbolProps) {
-            if (changeTracker.assigned_[sym.toString()] === true) {
-              const value = changeTracker.copy_[sym];
-              changes[sym.toString()] = deepClone(value);
-            }
-          }
-          return changes;
-        }
-        return changeTracker.changes;
-      }
-      if (changeTracker.modified && !parent) {
-        debugLog(`Root object with nested changes, checking deep equality`);
-        const currentState = changeTracker.copy_ || target;
-        debugLog(
-          `Comparing current state with original:`,
-          currentState,
-          changeTracker.originalObject
-        );
-        if (deepEqual(currentState, changeTracker.originalObject)) {
-          debugLog(`Current state equals original, returning empty object`);
-          changeTracker.modified = false;
-          return {};
-        }
-        debugLog(
-          `Comparing target with original:`,
-          target,
-          changeTracker.originalObject
-        );
-        if (deepEqual(target, changeTracker.originalObject)) {
-          debugLog(`Target equals original, returning empty object`);
-          changeTracker.modified = false;
-          changeTracker.changes = {};
-          changeTracker.assigned_ = {};
-          return {};
-        }
-        if (typeof target === `object` && target !== null) {
-          let allNestedReverted = true;
-          for (const key in target) {
-            if (Object.prototype.hasOwnProperty.call(target, key)) {
-              const currentValue = target[key];
-              const originalValue = changeTracker.originalObject[key];
-              if (!deepEqual(currentValue, originalValue)) {
-                allNestedReverted = false;
-                break;
-              }
-            }
-          }
-          if (allNestedReverted) {
-            debugLog(
-              `All nested properties match original values, returning empty object`
-            );
-            changeTracker.modified = false;
-            changeTracker.changes = {};
-            changeTracker.assigned_ = {};
-            return {};
-          }
-        }
-        debugLog(
-          `Changes detected, returning full object:`,
-          changeTracker.copy_ || target
-        );
-        const result = changeTracker.copy_ || target;
-        return result;
-      }
-      debugLog(`No changes detected, returning empty object`);
-      return {};
+      debugLog(`Returning copy:`, result);
+      return result;
     }
   };
 }
@@ -621,32 +486,6 @@ function withArrayChangeTracking(targets, callback) {
   callback(proxies);
   return getChanges();
 }
-function prepareCopy(state) {
-  if (!state.copy_) {
-    state.copy_ = shallowCopy(state.originalObject);
-  }
-}
-function shallowCopy(obj) {
-  if (Array.isArray(obj)) {
-    return [...obj];
-  }
-  if (obj instanceof Map) {
-    return new Map(obj);
-  }
-  if (obj instanceof Set) {
-    return new Set(obj);
-  }
-  if (obj instanceof Date) {
-    return new Date(obj.getTime());
-  }
-  if (obj instanceof RegExp) {
-    return new RegExp(obj.source, obj.flags);
-  }
-  if (obj !== null && typeof obj === `object`) {
-    return { ...obj };
-  }
-  return obj;
-}
 exports.createArrayChangeProxy = createArrayChangeProxy;
 exports.createChangeProxy = createChangeProxy;
 exports.withArrayChangeTracking = withArrayChangeTracking;