@tanstack/db 0.0.7 → 0.0.8

package/dist/cjs/collection.cjs

@@ -4,10 +4,8 @@ const store = require("@tanstack/store");
 const proxy = require("./proxy.cjs");
 const transactions = require("./transactions.cjs");
 const SortedMap = require("./SortedMap.cjs");
-const collectionsStore = new store.Store(
-  /* @__PURE__ */ new Map()
-);
-const loadingCollections = /* @__PURE__ */ new Map();
+const collectionsStore = /* @__PURE__ */ new Map();
+const loadingCollectionResolvers = /* @__PURE__ */ new Map();
 function createCollection(options) {
   const collection = new CollectionImpl(options);
   if (options.utils) {
@@ -21,52 +19,44 @@ function preloadCollection(config) {
   if (!config.id) {
     throw new Error(`The id property is required for preloadCollection`);
   }
-  if (collectionsStore.state.has(config.id) && !loadingCollections.has(config.id)) {
+  if (collectionsStore.has(config.id) && !loadingCollectionResolvers.has(config.id)) {
     return Promise.resolve(
-      collectionsStore.state.get(config.id)
+      collectionsStore.get(config.id)
     );
   }
-  if (loadingCollections.has(config.id)) {
-    return loadingCollections.get(config.id);
+  if (loadingCollectionResolvers.has(config.id)) {
+    return loadingCollectionResolvers.get(config.id).promise;
   }
-  if (!collectionsStore.state.has(config.id)) {
-    collectionsStore.setState((prev) => {
-      const next = new Map(prev);
-      if (!config.id) {
-        throw new Error(`The id property is required for preloadCollection`);
-      }
-      next.set(
-        config.id,
-        createCollection({
-          id: config.id,
-          getId: config.getId,
-          sync: config.sync,
-          schema: config.schema
-        })
-      );
-      return next;
-    });
+  if (!collectionsStore.has(config.id)) {
+    collectionsStore.set(
+      config.id,
+      createCollection({
+        id: config.id,
+        getKey: config.getKey,
+        sync: config.sync,
+        schema: config.schema
+      })
+    );
   }
-  const collection = collectionsStore.state.get(config.id);
+  const collection = collectionsStore.get(config.id);
   let resolveFirstCommit;
   const firstCommitPromise = new Promise((resolve) => {
-    resolveFirstCommit = () => {
-      resolve(collection);
-    };
+    resolveFirstCommit = resolve;
+  });
+  loadingCollectionResolvers.set(config.id, {
+    promise: firstCommitPromise,
+    resolve: resolveFirstCommit
   });
   collection.onFirstCommit(() => {
     if (!config.id) {
       throw new Error(`The id property is required for preloadCollection`);
     }
-    if (loadingCollections.has(config.id)) {
-      loadingCollections.delete(config.id);
-      resolveFirstCommit();
+    if (loadingCollectionResolvers.has(config.id)) {
+      const resolver = loadingCollectionResolvers.get(config.id);
+      loadingCollectionResolvers.delete(config.id);
+      resolver.resolve(collection);
     }
   });
-  loadingCollections.set(
-    config.id,
-    firstCommitPromise
-  );
   return firstCommitPromise;
 }
 class SchemaValidationError extends Error {
@@ -86,59 +76,94 @@ class CollectionImpl {
    * @throws Error if sync config is missing
    */
   constructor(config) {
+    this.syncedData = /* @__PURE__ */ new Map();
+    this.syncedMetadata = /* @__PURE__ */ new Map();
+    this.derivedUpserts = /* @__PURE__ */ new Map();
+    this.derivedDeletes = /* @__PURE__ */ new Set();
+    this._size = 0;
+    this.changeListeners = /* @__PURE__ */ new Set();
+    this.changeKeyListeners = /* @__PURE__ */ new Map();
     this.utils = {};
-    this.syncedData = new store.Store(/* @__PURE__ */ new Map());
-    this.syncedMetadata = new store.Store(/* @__PURE__ */ new Map());
     this.pendingSyncedTransactions = [];
     this.syncedKeys = /* @__PURE__ */ new Set();
     this.hasReceivedFirstCommit = false;
     this.onFirstCommitCallbacks = [];
     this.id = ``;
     this.commitPendingTransactions = () => {
-      if (!Array.from(this.transactions.state.values()).some(
+      if (!Array.from(this.transactions.values()).some(
         ({ state }) => state === `persisting`
       )) {
-        store.batch(() => {
-          for (const transaction of this.pendingSyncedTransactions) {
-            for (const operation of transaction.operations) {
-              this.syncedKeys.add(operation.key);
-              this.syncedMetadata.setState((prevData) => {
-                switch (operation.type) {
-                  case `insert`:
-                    prevData.set(operation.key, operation.metadata);
-                    break;
-                  case `update`:
-                    prevData.set(operation.key, {
-                      ...prevData.get(operation.key),
-                      ...operation.metadata
-                    });
-                    break;
-                  case `delete`:
-                    prevData.delete(operation.key);
-                    break;
+        const changedKeys = /* @__PURE__ */ new Set();
+        const events = [];
+        for (const transaction of this.pendingSyncedTransactions) {
+          for (const operation of transaction.operations) {
+            const key = operation.key;
+            changedKeys.add(key);
+            this.syncedKeys.add(key);
+            switch (operation.type) {
+              case `insert`:
+                this.syncedMetadata.set(key, operation.metadata);
+                break;
+              case `update`:
+                this.syncedMetadata.set(
+                  key,
+                  Object.assign(
+                    {},
+                    this.syncedMetadata.get(key),
+                    operation.metadata
+                  )
+                );
+                break;
+              case `delete`:
+                this.syncedMetadata.delete(key);
+                break;
+            }
+            const previousValue = this.syncedData.get(key);
+            switch (operation.type) {
+              case `insert`:
+                this.syncedData.set(key, operation.value);
+                if (!this.derivedDeletes.has(key) && !this.derivedUpserts.has(key)) {
+                  events.push({
+                    type: `insert`,
+                    key,
+                    value: operation.value
+                  });
                 }
-                return prevData;
-              });
-              this.syncedData.setState((prevData) => {
-                switch (operation.type) {
-                  case `insert`:
-                    prevData.set(operation.key, operation.value);
-                    break;
-                  case `update`:
-                    prevData.set(operation.key, {
-                      ...prevData.get(operation.key),
-                      ...operation.value
+                break;
+              case `update`: {
+                const updatedValue = Object.assign(
+                  {},
+                  this.syncedData.get(key),
+                  operation.value
+                );
+                this.syncedData.set(key, updatedValue);
+                if (!this.derivedDeletes.has(key) && !this.derivedUpserts.has(key)) {
+                  events.push({
+                    type: `update`,
+                    key,
+                    value: updatedValue,
+                    previousValue
+                  });
+                }
+                break;
+              }
+              case `delete`:
+                this.syncedData.delete(key);
+                if (!this.derivedDeletes.has(key) && !this.derivedUpserts.has(key)) {
+                  if (previousValue) {
+                    events.push({
+                      type: `delete`,
+                      key,
+                      value: previousValue
                     });
-                    break;
-                  case `delete`:
-                    prevData.delete(operation.key);
-                    break;
+                  }
                 }
-                return prevData;
-              });
+                break;
             }
           }
-        });
+        }
+        this._size = this.calculateSize();
+        this.emitEvents(events);
         this.pendingSyncedTransactions = [];
         if (!this.hasReceivedFirstCommit) {
           this.hasReceivedFirstCommit = true;
@@ -157,22 +182,20 @@ class CollectionImpl {
       }
       const items = Array.isArray(data) ? data : [data];
       const mutations = [];
-      const keys = items.map(
-        (item) => this.generateObjectKey(this.config.getId(item), item)
-      );
-      items.forEach((item, index) => {
+      items.forEach((item) => {
         var _a, _b;
         const validatedData = this.validateData(item, `insert`);
-        const key = keys[index];
-        const id = this.config.getId(item);
-        if (this.state.has(this.getKeyFromId(id))) {
-          throw `Cannot insert document with ID "${id}" because it already exists in the collection`;
+        const key = this.getKeyFromItem(item);
+        if (this.has(key)) {
+          throw `Cannot insert document with ID "${key}" because it already exists in the collection`;
         }
+        const globalKey = this.generateGlobalKey(key, item);
         const mutation = {
           mutationId: crypto.randomUUID(),
           original: {},
           modified: validatedData,
           changes: validatedData,
+          globalKey,
           key,
           metadata: config2 == null ? void 0 : config2.metadata,
           syncMetadata: ((_b = (_a = this.config.sync).getSyncMetadata) == null ? void 0 : _b.call(_a)) || {},
@@ -185,10 +208,8 @@ class CollectionImpl {
       });
       if (ambientTransaction) {
         ambientTransaction.applyMutations(mutations);
-        this.transactions.setState((sortedMap) => {
-          sortedMap.set(ambientTransaction.id, ambientTransaction);
-          return sortedMap;
-        });
+        this.transactions.set(ambientTransaction.id, ambientTransaction);
+        this.recomputeOptimisticState();
         return ambientTransaction;
       } else {
         const directOpTransaction = new transactions.Transaction({
@@ -198,33 +219,34 @@ class CollectionImpl {
         });
         directOpTransaction.applyMutations(mutations);
         directOpTransaction.commit();
-        this.transactions.setState((sortedMap) => {
-          sortedMap.set(directOpTransaction.id, directOpTransaction);
-          return sortedMap;
-        });
+        this.transactions.set(directOpTransaction.id, directOpTransaction);
+        this.recomputeOptimisticState();
         return directOpTransaction;
       }
     };
-    this.delete = (ids, config2) => {
+    this.delete = (keys, config2) => {
       const ambientTransaction = transactions.getActiveTransaction();
       if (!ambientTransaction && !this.config.onDelete) {
         throw new Error(
           `Collection.delete called directly (not within an explicit transaction) but no 'onDelete' handler is configured.`
         );
       }
-      const idsArray = (Array.isArray(ids) ? ids : [ids]).map(
-        (id) => this.getKeyFromId(id)
-      );
+      if (Array.isArray(keys) && keys.length === 0) {
+        throw new Error(`No keys were passed to delete`);
+      }
+      const keysArray = Array.isArray(keys) ? keys : [keys];
       const mutations = [];
-      for (const id of idsArray) {
+      for (const key of keysArray) {
+        const globalKey = this.generateGlobalKey(key, this.get(key));
         const mutation = {
           mutationId: crypto.randomUUID(),
-          original: this.state.get(id) || {},
-          modified: this.state.get(id) || {},
-          changes: this.state.get(id) || {},
-          key: id,
+          original: this.get(key) || {},
+          modified: this.get(key),
+          changes: this.get(key) || {},
+          globalKey,
+          key,
           metadata: config2 == null ? void 0 : config2.metadata,
-          syncMetadata: this.syncedMetadata.state.get(id) || {},
+          syncMetadata: this.syncedMetadata.get(key) || {},
           type: `delete`,
           createdAt: /* @__PURE__ */ new Date(),
           updatedAt: /* @__PURE__ */ new Date(),
@@ -234,24 +256,20 @@ class CollectionImpl {
       }
       if (ambientTransaction) {
         ambientTransaction.applyMutations(mutations);
-        this.transactions.setState((sortedMap) => {
-          sortedMap.set(ambientTransaction.id, ambientTransaction);
-          return sortedMap;
-        });
+        this.transactions.set(ambientTransaction.id, ambientTransaction);
+        this.recomputeOptimisticState();
         return ambientTransaction;
       }
       const directOpTransaction = new transactions.Transaction({
         autoCommit: true,
-        mutationFn: async (transaction) => {
-          return this.config.onDelete(transaction);
+        mutationFn: async (params) => {
+          return this.config.onDelete(params);
         }
       });
       directOpTransaction.applyMutations(mutations);
       directOpTransaction.commit();
-      this.transactions.setState((sortedMap) => {
-        sortedMap.set(directOpTransaction.id, directOpTransaction);
-        return sortedMap;
-      });
+      this.transactions.set(directOpTransaction.id, directOpTransaction);
+      this.recomputeOptimisticState();
       return directOpTransaction;
     };
     if (!config) {
@@ -265,121 +283,10 @@ class CollectionImpl {
     if (!config.sync) {
       throw new Error(`Collection requires a sync config`);
     }
-    this.transactions = new store.Store(
-      new SortedMap.SortedMap(
-        (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
-      )
+    this.transactions = new SortedMap.SortedMap(
+      (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
     );
-    this.optimisticOperations = new store.Derived({
-      fn: ({ currDepVals: [transactions2] }) => {
-        const result = Array.from(transactions2.values()).map((transaction) => {
-          const isActive = ![`completed`, `failed`].includes(
-            transaction.state
-          );
-          return transaction.mutations.filter((mutation) => mutation.collection === this).map((mutation) => {
-            const message = {
-              type: mutation.type,
-              key: mutation.key,
-              value: mutation.modified,
-              isActive
-            };
-            if (mutation.metadata !== void 0 && mutation.metadata !== null) {
-              message.metadata = mutation.metadata;
-            }
-            return message;
-          });
-        }).flat();
-        return result;
-      },
-      deps: [this.transactions]
-    });
-    this.optimisticOperations.mount();
-    this.derivedState = new store.Derived({
-      fn: ({ currDepVals: [syncedData, operations] }) => {
-        const combined = new Map(syncedData);
-        for (const operation of operations) {
-          if (operation.isActive) {
-            switch (operation.type) {
-              case `insert`:
-                combined.set(operation.key, operation.value);
-                break;
-              case `update`:
-                combined.set(operation.key, operation.value);
-                break;
-              case `delete`:
-                combined.delete(operation.key);
-                break;
-            }
-          }
-        }
-        return combined;
-      },
-      deps: [this.syncedData, this.optimisticOperations]
-    });
-    this.derivedArray = new store.Derived({
-      fn: ({ currDepVals: [stateMap] }) => {
-        const array = Array.from(
-          stateMap.values()
-        );
-        if (array[0] && `_orderByIndex` in array[0]) {
-          array.sort((a, b) => {
-            if (a._orderByIndex === b._orderByIndex) {
-              return 0;
-            }
-            return a._orderByIndex < b._orderByIndex ? -1 : 1;
-          });
-        }
-        return array;
-      },
-      deps: [this.derivedState]
-    });
-    this.derivedArray.mount();
-    this.derivedChanges = new store.Derived({
-      fn: ({
-        currDepVals: [derivedState, optimisticOperations],
-        prevDepVals
-      }) => {
-        const prevDerivedState = (prevDepVals == null ? void 0 : prevDepVals[0]) ?? /* @__PURE__ */ new Map();
-        const prevOptimisticOperations = (prevDepVals == null ? void 0 : prevDepVals[1]) ?? [];
-        const changedKeys = new Set(this.syncedKeys);
-        optimisticOperations.flat().filter((op) => op.isActive).forEach((op) => changedKeys.add(op.key));
-        prevOptimisticOperations.flat().forEach((op) => {
-          changedKeys.add(op.key);
-        });
-        if (changedKeys.size === 0) {
-          return [];
-        }
-        const changes = [];
-        for (const key of changedKeys) {
-          if (prevDerivedState.has(key) && !derivedState.has(key)) {
-            changes.push({
-              type: `delete`,
-              key,
-              value: prevDerivedState.get(key)
-            });
-          } else if (!prevDerivedState.has(key) && derivedState.has(key)) {
-            changes.push({ type: `insert`, key, value: derivedState.get(key) });
-          } else if (prevDerivedState.has(key) && derivedState.has(key)) {
-            const value = derivedState.get(key);
-            const previousValue = prevDerivedState.get(key);
-            if (value !== previousValue) {
-              changes.push({
-                type: `update`,
-                key,
-                value,
-                previousValue
-              });
-            }
-          }
-        }
-        this.syncedKeys.clear();
-        return changes;
-      },
-      deps: [this.derivedState, this.optimisticOperations]
-    });
-    this.derivedChanges.mount();
     this.config = config;
-    this.derivedState.mount();
     config.sync.sync({
       collection: this,
       begin: () => {
@@ -398,17 +305,13 @@ class CollectionImpl {
             `The pending sync transaction is already committed, you can't still write to it.`
           );
         }
-        const key = this.generateObjectKey(
-          this.config.getId(messageWithoutKey.value),
-          messageWithoutKey.value
-        );
+        const key = this.getKeyFromItem(messageWithoutKey.value);
         if (messageWithoutKey.type === `insert`) {
-          if (this.syncedData.state.has(key) && !pendingTransaction.operations.some(
+          if (this.syncedData.has(key) && !pendingTransaction.operations.some(
             (op) => op.key === key && op.type === `delete`
           )) {
-            const id = this.config.getId(messageWithoutKey.value);
             throw new Error(
-              `Cannot insert document with ID "${id}" from sync because it already exists in the collection "${this.id}"`
+              `Cannot insert document with key "${key}" from sync because it already exists in the collection "${this.id}"`
             );
           }
         }
@@ -441,6 +344,189 @@ class CollectionImpl {
   onFirstCommit(callback) {
     this.onFirstCommitCallbacks.push(callback);
   }
+  /**
+   * Recompute optimistic state from active transactions
+   */
+  recomputeOptimisticState() {
+    const previousState = new Map(this.derivedUpserts);
+    const previousDeletes = new Set(this.derivedDeletes);
+    this.derivedUpserts.clear();
+    this.derivedDeletes.clear();
+    const activeTransactions = Array.from(this.transactions.values());
+    for (const transaction of activeTransactions) {
+      if (![`completed`, `failed`].includes(transaction.state)) {
+        for (const mutation of transaction.mutations) {
+          if (mutation.collection === this) {
+            switch (mutation.type) {
+              case `insert`:
+              case `update`:
+                this.derivedUpserts.set(mutation.key, mutation.modified);
+                this.derivedDeletes.delete(mutation.key);
+                break;
+              case `delete`:
+                this.derivedUpserts.delete(mutation.key);
+                this.derivedDeletes.add(mutation.key);
+                break;
+            }
+          }
+        }
+      }
+    }
+    this._size = this.calculateSize();
+    const events = [];
+    this.collectOptimisticChanges(previousState, previousDeletes, events);
+    this.emitEvents(events);
+  }
+  /**
+   * Calculate the current size based on synced data and optimistic changes
+   */
+  calculateSize() {
+    const syncedSize = this.syncedData.size;
+    const deletesFromSynced = Array.from(this.derivedDeletes).filter(
+      (key) => this.syncedData.has(key) && !this.derivedUpserts.has(key)
+    ).length;
+    const upsertsNotInSynced = Array.from(this.derivedUpserts.keys()).filter(
+      (key) => !this.syncedData.has(key)
+    ).length;
+    return syncedSize - deletesFromSynced + upsertsNotInSynced;
+  }
+  /**
+   * Collect events for optimistic changes
+   */
+  collectOptimisticChanges(previousUpserts, previousDeletes, events) {
+    const allKeys = /* @__PURE__ */ new Set([
+      ...previousUpserts.keys(),
+      ...this.derivedUpserts.keys(),
+      ...previousDeletes,
+      ...this.derivedDeletes
+    ]);
+    for (const key of allKeys) {
+      const currentValue = this.get(key);
+      const previousValue = this.getPreviousValue(
+        key,
+        previousUpserts,
+        previousDeletes
+      );
+      if (previousValue !== void 0 && currentValue === void 0) {
+        events.push({ type: `delete`, key, value: previousValue });
+      } else if (previousValue === void 0 && currentValue !== void 0) {
+        events.push({ type: `insert`, key, value: currentValue });
+      } else if (previousValue !== void 0 && currentValue !== void 0 && previousValue !== currentValue) {
+        events.push({
+          type: `update`,
+          key,
+          value: currentValue,
+          previousValue
+        });
+      }
+    }
+  }
+  /**
+   * Get the previous value for a key given previous optimistic state
+   */
+  getPreviousValue(key, previousUpserts, previousDeletes) {
+    if (previousDeletes.has(key)) {
+      return void 0;
+    }
+    if (previousUpserts.has(key)) {
+      return previousUpserts.get(key);
+    }
+    return this.syncedData.get(key);
+  }
+  /**
+   * Emit multiple events at once to all listeners
+   */
+  emitEvents(changes) {
+    if (changes.length > 0) {
+      for (const listener of this.changeListeners) {
+        listener(changes);
+      }
+      if (this.changeKeyListeners.size > 0) {
+        const changesByKey = /* @__PURE__ */ new Map();
+        for (const change of changes) {
+          if (this.changeKeyListeners.has(change.key)) {
+            if (!changesByKey.has(change.key)) {
+              changesByKey.set(change.key, []);
+            }
+            changesByKey.get(change.key).push(change);
+          }
+        }
+        for (const [key, keyChanges] of changesByKey) {
+          const keyListeners = this.changeKeyListeners.get(key);
+          for (const listener of keyListeners) {
+            listener(keyChanges);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Get the current value for a key (virtual derived state)
+   */
+  get(key) {
+    if (this.derivedDeletes.has(key)) {
+      return void 0;
+    }
+    if (this.derivedUpserts.has(key)) {
+      return this.derivedUpserts.get(key);
+    }
+    return this.syncedData.get(key);
+  }
+  /**
+   * Check if a key exists in the collection (virtual derived state)
+   */
+  has(key) {
+    if (this.derivedDeletes.has(key)) {
+      return false;
+    }
+    if (this.derivedUpserts.has(key)) {
+      return true;
+    }
+    return this.syncedData.has(key);
+  }
+  /**
+   * Get the current size of the collection (cached)
+   */
+  get size() {
+    return this._size;
+  }
+  /**
+   * Get all keys (virtual derived state)
+   */
+  *keys() {
+    for (const key of this.syncedData.keys()) {
+      if (!this.derivedDeletes.has(key)) {
+        yield key;
+      }
+    }
+    for (const key of this.derivedUpserts.keys()) {
+      if (!this.syncedData.has(key) && !this.derivedDeletes.has(key)) {
+        yield key;
+      }
+    }
+  }
+  /**
+   * Get all values (virtual derived state)
+   */
+  *values() {
+    for (const key of this.keys()) {
+      const value = this.get(key);
+      if (value !== void 0) {
+        yield value;
+      }
+    }
+  }
+  /**
+   * Get all entries (virtual derived state)
+   */
+  *entries() {
+    for (const key of this.keys()) {
+      const value = this.get(key);
+      if (value !== void 0) {
+        yield [key, value];
+      }
+    }
+  }
   ensureStandardSchema(schema) {
     if (schema && typeof schema === `object` && `~standard` in schema) {
       return schema;
@@ -449,31 +535,24 @@ class CollectionImpl {
       `Schema must either implement the standard-schema interface or be a Zod schema`
     );
   }
-  getKeyFromId(id) {
-    if (typeof id === `undefined`) {
-      throw new Error(`id is undefined`);
-    }
-    if (typeof id === `string` && id.startsWith(`KEY::`)) {
-      return id;
-    } else {
-      return this.generateObjectKey(id, null);
-    }
+  getKeyFromItem(item) {
+    return this.config.getKey(item);
   }
-  generateObjectKey(id, item) {
-    if (typeof id === `undefined`) {
+  generateGlobalKey(key, item) {
+    if (typeof key === `undefined`) {
       throw new Error(
-        `An object was created without a defined id: ${JSON.stringify(item)}`
+        `An object was created without a defined key: ${JSON.stringify(item)}`
       );
     }
-    return `KEY::${this.id}/${id}`;
+    return `KEY::${this.id}/${key}`;
   }
   validateData(data, type, key) {
     if (!this.config.schema) return data;
     const standardSchema = this.ensureStandardSchema(this.config.schema);
     if (type === `update` && key) {
-      const existingData = this.state.get(key);
+      const existingData = this.get(key);
       if (existingData && data && typeof data === `object` && typeof existingData === `object`) {
-        const mergedData = { ...existingData, ...data };
+        const mergedData = Object.assign({}, existingData, data);
         const result2 = standardSchema[`~standard`].validate(mergedData);
         if (result2 instanceof Promise) {
           throw new TypeError(`Schema validation must be synchronous`);
@@ -507,8 +586,8 @@ class CollectionImpl {
     }
     return result.value;
   }
-  update(ids, configOrCallback, maybeCallback) {
-    if (typeof ids === `undefined`) {
+  update(keys, configOrCallback, maybeCallback) {
+    if (typeof keys === `undefined`) {
       throw new Error(`The first argument to update is missing`);
     }
     const ambientTransaction = transactions.getActiveTransaction();
@@ -517,17 +596,18 @@ class CollectionImpl {
         `Collection.update called directly (not within an explicit transaction) but no 'onUpdate' handler is configured.`
       );
     }
-    const isArray = Array.isArray(ids);
-    const idsArray = (Array.isArray(ids) ? ids : [ids]).map(
-      (id) => this.getKeyFromId(id)
-    );
+    const isArray = Array.isArray(keys);
+    const keysArray = isArray ? keys : [keys];
+    if (isArray && keysArray.length === 0) {
+      throw new Error(`No keys were passed to update`);
+    }
     const callback = typeof configOrCallback === `function` ? configOrCallback : maybeCallback;
     const config = typeof configOrCallback === `function` ? {} : configOrCallback;
-    const currentObjects = idsArray.map((id) => {
-      const item = this.state.get(id);
+    const currentObjects = keysArray.map((key) => {
+      const item = this.get(key);
       if (!item) {
         throw new Error(
-          `The id "${id}" was passed to update but an object for this ID was not found in the collection`
+          `The key "${key}" was passed to update but an object for this key was not found in the collection`
         );
       }
       return item;
@@ -545,7 +625,7 @@ class CollectionImpl {
       );
       changesArray = [result];
     }
-    const mutations = idsArray.map((id, index) => {
+    const mutations = keysArray.map((key, index) => {
       const itemChanges = changesArray[index];
       if (!itemChanges || Object.keys(itemChanges).length === 0) {
         return null;
@@ -554,24 +634,30 @@ class CollectionImpl {
       const validatedUpdatePayload = this.validateData(
         itemChanges,
         `update`,
-        id
+        key
+      );
+      const modifiedItem = Object.assign(
+        {},
+        originalItem,
+        validatedUpdatePayload
       );
-      const modifiedItem = { ...originalItem, ...validatedUpdatePayload };
-      const originalItemId = this.config.getId(originalItem);
-      const modifiedItemId = this.config.getId(modifiedItem);
+      const originalItemId = this.getKeyFromItem(originalItem);
+      const modifiedItemId = this.getKeyFromItem(modifiedItem);
       if (originalItemId !== modifiedItemId) {
         throw new Error(
-          `Updating the ID of an item is not allowed. Original ID: "${originalItemId}", Attempted new ID: "${modifiedItemId}". Please delete the old item and create a new one if an ID change is necessary.`
+          `Updating the key of an item is not allowed. Original key: "${originalItemId}", Attempted new key: "${modifiedItemId}". Please delete the old item and create a new one if a key change is necessary.`
         );
       }
+      const globalKey = this.generateGlobalKey(modifiedItemId, modifiedItem);
       return {
         mutationId: crypto.randomUUID(),
         original: originalItem,
         modified: modifiedItem,
         changes: validatedUpdatePayload,
-        key: id,
+        globalKey,
+        key,
         metadata: config.metadata,
-        syncMetadata: this.syncedMetadata.state.get(id) || {},
+        syncMetadata: this.syncedMetadata.get(key) || {},
         type: `update`,
         createdAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date(),
@@ -583,23 +669,19 @@ class CollectionImpl {
     }
     if (ambientTransaction) {
       ambientTransaction.applyMutations(mutations);
-      this.transactions.setState((sortedMap) => {
-        sortedMap.set(ambientTransaction.id, ambientTransaction);
-        return sortedMap;
-      });
+      this.transactions.set(ambientTransaction.id, ambientTransaction);
+      this.recomputeOptimisticState();
       return ambientTransaction;
     }
     const directOpTransaction = new transactions.Transaction({
-      mutationFn: async (transaction) => {
-        return this.config.onUpdate(transaction);
+      mutationFn: async (params) => {
+        return this.config.onUpdate(params);
       }
     });
     directOpTransaction.applyMutations(mutations);
     directOpTransaction.commit();
-    this.transactions.setState((sortedMap) => {
-      sortedMap.set(directOpTransaction.id, directOpTransaction);
-      return sortedMap;
-    });
+    this.transactions.set(directOpTransaction.id, directOpTransaction);
+    this.recomputeOptimisticState();
     return directOpTransaction;
   }
   /**
@@ -608,7 +690,11 @@ class CollectionImpl {
    * @returns A Map containing all items in the collection, with keys as identifiers
    */
   get state() {
-    return this.derivedState.state;
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, value] of this.entries()) {
+      result.set(key, value);
+    }
+    return result;
   }
   /**
    * Gets the current state of the collection as a Map, but only resolves when data is available
@@ -617,7 +703,7 @@ class CollectionImpl {
    * @returns Promise that resolves to a Map containing all items in the collection
    */
   stateWhenReady() {
-    if (this.state.size > 0 || this.hasReceivedFirstCommit === true) {
+    if (this.size > 0 || this.hasReceivedFirstCommit === true) {
       return Promise.resolve(this.state);
     }
     return new Promise((resolve) => {
@@ -632,7 +718,13 @@ class CollectionImpl {
    * @returns An Array containing all items in the collection
    */
   get toArray() {
-    return this.derivedArray.state;
+    const array = Array.from(this.values());
+    if (array[0] && array[0]._orderByIndex) {
+      return array.sort(
+        (a, b) => a._orderByIndex - b._orderByIndex
+      );
+    }
+    return array;
   }
   /**
    * Gets the current state of the collection as an Array, but only resolves when data is available
@@ -641,7 +733,7 @@ class CollectionImpl {
    * @returns Promise that resolves to an Array containing all items in the collection
    */
   toArrayWhenReady() {
-    if (this.toArray.length > 0 || this.hasReceivedFirstCommit === true) {
+    if (this.size > 0 || this.hasReceivedFirstCommit === true) {
       return Promise.resolve(this.toArray);
     }
     return new Promise((resolve) => {
@@ -655,7 +747,7 @@ class CollectionImpl {
    * @returns An array of changes
    */
   currentStateAsChanges() {
-    return [...this.state.entries()].map(([key, value]) => ({
+    return Array.from(this.entries()).map(([key, value]) => ({
       type: `insert`,
       key,
       value
@@ -666,13 +758,78 @@ class CollectionImpl {
    * @param callback - A function that will be called with the changes in the collection
    * @returns A function that can be called to unsubscribe from the changes
    */
-  subscribeChanges(callback) {
-    callback(this.currentStateAsChanges());
-    return this.derivedChanges.subscribe((changes) => {
-      if (changes.currentVal.length > 0) {
-        callback(changes.currentVal);
+  subscribeChanges(callback, { includeInitialState = false } = {}) {
+    if (includeInitialState) {
+      callback(this.currentStateAsChanges());
+    }
+    this.changeListeners.add(callback);
+    return () => {
+      this.changeListeners.delete(callback);
+    };
+  }
+  /**
+   * Subscribe to changes for a specific key
+   */
+  subscribeChangesKey(key, listener, { includeInitialState = false } = {}) {
+    if (!this.changeKeyListeners.has(key)) {
+      this.changeKeyListeners.set(key, /* @__PURE__ */ new Set());
+    }
+    if (includeInitialState) {
+      listener([
+        {
+          type: `insert`,
+          key,
+          value: this.get(key)
+        }
+      ]);
+    }
+    this.changeKeyListeners.get(key).add(listener);
+    return () => {
+      const listeners = this.changeKeyListeners.get(key);
+      if (listeners) {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          this.changeKeyListeners.delete(key);
+        }
       }
-    });
+    };
+  }
+  /**
+   * Trigger a recomputation when transactions change
+   * This method should be called by the Transaction class when state changes
+   */
+  onTransactionStateChange() {
+    this.recomputeOptimisticState();
+  }
+  /**
+   * Returns a Tanstack Store Map that is updated when the collection changes
+   * This is a temporary solution to enable the existing framework hooks to work
+   * with the new internals of Collection until they are rewritten.
+   * TODO: Remove this once the framework hooks are rewritten.
+   */
+  asStoreMap() {
+    if (!this._storeMap) {
+      this._storeMap = new store.Store(new Map(this.entries()));
+      this.subscribeChanges(() => {
+        this._storeMap.setState(() => new Map(this.entries()));
+      });
+    }
+    return this._storeMap;
+  }
+  /**
+   * Returns a Tanstack Store Array that is updated when the collection changes
+   * This is a temporary solution to enable the existing framework hooks to work
+   * with the new internals of Collection until they are rewritten.
+   * TODO: Remove this once the framework hooks are rewritten.
+   */
+  asStoreArray() {
+    if (!this._storeArray) {
+      this._storeArray = new store.Store(this.toArray);
+      this.subscribeChanges(() => {
+        this._storeArray.setState(() => this.toArray);
+      });
+    }
+    return this._storeArray;
   }
 }
 exports.CollectionImpl = CollectionImpl;