@tanstack/db 0.0.1

package/dist/cjs/transactions.cjs

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const deferred = require("./deferred.cjs");
+function generateUUID() {
+  if (typeof crypto !== `undefined` && typeof crypto.randomUUID === `function`) {
+    return crypto.randomUUID();
+  }
+  return `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`.replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === `x` ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+const transactions = [];
+function createTransaction(config) {
+  if (typeof config.mutationFn === `undefined`) {
+    throw `mutationFn is required when creating a transaction`;
+  }
+  let transactionId = config.id;
+  if (!transactionId) {
+    transactionId = generateUUID();
+  }
+  const newTransaction = new Transaction({ ...config, id: transactionId });
+  transactions.push(newTransaction);
+  return newTransaction;
+}
+let transactionStack = [];
+function getActiveTransaction() {
+  if (transactionStack.length > 0) {
+    return transactionStack.slice(-1)[0];
+  } else {
+    return void 0;
+  }
+}
+function registerTransaction(tx) {
+  transactionStack.push(tx);
+}
+function unregisterTransaction(tx) {
+  transactionStack = transactionStack.filter((t) => t.id !== tx.id);
+}
+class Transaction {
+  constructor(config) {
+    this.id = config.id;
+    this.mutationFn = config.mutationFn;
+    this.state = `pending`;
+    this.mutations = [];
+    this.isPersisted = deferred.createDeferred();
+    this.autoCommit = config.autoCommit ?? true;
+    this.createdAt = /* @__PURE__ */ new Date();
+    this.metadata = config.metadata ?? {};
+  }
+  setState(newState) {
+    this.state = newState;
+  }
+  mutate(callback) {
+    if (this.state !== `pending`) {
+      throw `You can no longer call .mutate() as the transaction is no longer pending`;
+    }
+    registerTransaction(this);
+    try {
+      callback();
+    } finally {
+      unregisterTransaction(this);
+    }
+    if (this.autoCommit) {
+      this.commit();
+    }
+    return this;
+  }
+  applyMutations(mutations) {
+    for (const newMutation of mutations) {
+      const existingIndex = this.mutations.findIndex(
+        (m) => m.key === newMutation.key
+      );
+      if (existingIndex >= 0) {
+        this.mutations[existingIndex] = newMutation;
+      } else {
+        this.mutations.push(newMutation);
+      }
+    }
+  }
+  rollback(config) {
+    var _a;
+    const isSecondaryRollback = (config == null ? void 0 : config.isSecondaryRollback) ?? false;
+    if (this.state === `completed`) {
+      throw `You can no longer call .rollback() as the transaction is already completed`;
+    }
+    this.setState(`failed`);
+    if (!isSecondaryRollback) {
+      const mutationKeys = /* @__PURE__ */ new Set();
+      this.mutations.forEach((m) => mutationKeys.add(m.key));
+      transactions.forEach(
+        (t) => t.state === `pending` && t.mutations.some((m) => mutationKeys.has(m.key)) && t.rollback({ isSecondaryRollback: true })
+      );
+    }
+    this.isPersisted.reject((_a = this.error) == null ? void 0 : _a.error);
+    this.touchCollection();
+    return this;
+  }
+  // Tell collection that something has changed with the transaction
+  touchCollection() {
+    const hasCalled = /* @__PURE__ */ new Set();
+    this.mutations.forEach((mutation) => {
+      if (!hasCalled.has(mutation.collection.id)) {
+        mutation.collection.transactions.setState((state) => state);
+        mutation.collection.commitPendingTransactions();
+        hasCalled.add(mutation.collection.id);
+      }
+    });
+  }
+  async commit() {
+    if (this.state !== `pending`) {
+      throw `You can no longer call .commit() as the transaction is no longer pending`;
+    }
+    this.setState(`persisting`);
+    if (this.mutations.length === 0) {
+      this.setState(`completed`);
+    }
+    try {
+      await this.mutationFn({ transaction: this });
+      this.setState(`completed`);
+      this.touchCollection();
+      this.isPersisted.resolve(this);
+    } catch (error) {
+      this.error = {
+        message: error instanceof Error ? error.message : String(error),
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+      return this.rollback();
+    }
+    return this;
+  }
+}
+exports.Transaction = Transaction;
+exports.createTransaction = createTransaction;
+exports.getActiveTransaction = getActiveTransaction;
+//# sourceMappingURL=transactions.cjs.map

package/dist/cjs/transactions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.cjs","sources":["../../src/transactions.ts"],"sourcesContent":["import { createDeferred } from \"./deferred\"\nimport type { Deferred } from \"./deferred\"\nimport type {\n  PendingMutation,\n  TransactionConfig,\n  TransactionState,\n} from \"./types\"\n\nfunction generateUUID() {\n  // Check if crypto.randomUUID is available (modern browsers and Node.js 15+)\n  if (\n    typeof crypto !== `undefined` &&\n    typeof crypto.randomUUID === `function`\n  ) {\n    return crypto.randomUUID()\n  }\n\n  // Fallback implementation for older environments\n  return `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`.replace(/[xy]/g, function (c) {\n    const r = (Math.random() * 16) | 0\n    const v = c === `x` ? r : (r & 0x3) | 0x8\n    return v.toString(16)\n  })\n}\n\nconst transactions: Array<Transaction> = []\n\nexport function createTransaction(config: TransactionConfig): Transaction {\n  if (typeof config.mutationFn === `undefined`) {\n    throw `mutationFn is required when creating a transaction`\n  }\n\n  let transactionId = config.id\n  if (!transactionId) {\n    transactionId = generateUUID()\n  }\n  const newTransaction = new Transaction({ ...config, id: transactionId })\n  transactions.push(newTransaction)\n\n  return newTransaction\n}\n\nlet transactionStack: Array<Transaction> = []\n\nexport function getActiveTransaction(): Transaction | undefined {\n  if (transactionStack.length > 0) {\n    return transactionStack.slice(-1)[0]\n  } else {\n    return undefined\n  }\n}\n\nfunction registerTransaction(tx: Transaction) {\n  transactionStack.push(tx)\n}\n\nfunction unregisterTransaction(tx: Transaction) {\n  transactionStack = transactionStack.filter((t) => t.id !== tx.id)\n}\n\nexport class Transaction {\n  public id: string\n  public state: TransactionState\n  public mutationFn\n  public mutations: Array<PendingMutation<any>>\n  public isPersisted: Deferred<Transaction>\n  public autoCommit: boolean\n  public createdAt: Date\n  public metadata: Record<string, unknown>\n  public error?: {\n    message: string\n    error: Error\n  }\n\n  constructor(config: TransactionConfig) {\n    this.id = config.id!\n    this.mutationFn = config.mutationFn\n    this.state = `pending`\n    this.mutations = []\n    this.isPersisted = createDeferred()\n    this.autoCommit = config.autoCommit ?? true\n    this.createdAt = new Date()\n    this.metadata = config.metadata ?? {}\n  }\n\n  setState(newState: TransactionState) {\n    this.state = newState\n  }\n\n  mutate(callback: () => void): Transaction {\n    if (this.state !== `pending`) {\n      throw `You can no longer call .mutate() as the transaction is no longer pending`\n    }\n\n    registerTransaction(this)\n    try {\n      callback()\n    } finally {\n      unregisterTransaction(this)\n    }\n\n    if (this.autoCommit) {\n      this.commit()\n    }\n\n    return this\n  }\n\n  applyMutations(mutations: Array<PendingMutation<any>>): void {\n    for (const newMutation of mutations) {\n      const existingIndex = this.mutations.findIndex(\n        (m) => m.key === newMutation.key\n      )\n\n      if (existingIndex >= 0) {\n        // Replace existing mutation\n        this.mutations[existingIndex] = newMutation\n      } else {\n        // Insert new mutation\n        this.mutations.push(newMutation)\n      }\n    }\n  }\n\n  rollback(config?: { isSecondaryRollback?: boolean }): Transaction {\n    const isSecondaryRollback = config?.isSecondaryRollback ?? false\n    if (this.state === `completed`) {\n      throw `You can no longer call .rollback() as the transaction is already completed`\n    }\n\n    this.setState(`failed`)\n\n    // See if there's any other transactions w/ mutations on the same keys\n    // and roll them back as well.\n    if (!isSecondaryRollback) {\n      const mutationKeys = new Set()\n      this.mutations.forEach((m) => mutationKeys.add(m.key))\n      transactions.forEach(\n        (t) =>\n          t.state === `pending` &&\n          t.mutations.some((m) => mutationKeys.has(m.key)) &&\n          t.rollback({ isSecondaryRollback: true })\n      )\n    }\n\n    // Reject the promise\n    this.isPersisted.reject(this.error?.error)\n\n    this.touchCollection()\n\n    return this\n  }\n\n  // Tell collection that something has changed with the transaction\n  touchCollection(): void {\n    const hasCalled = new Set()\n    this.mutations.forEach((mutation) => {\n      if (!hasCalled.has(mutation.collection.id)) {\n        mutation.collection.transactions.setState((state) => state)\n        mutation.collection.commitPendingTransactions()\n        hasCalled.add(mutation.collection.id)\n      }\n    })\n  }\n\n  async commit(): Promise<Transaction> {\n    if (this.state !== `pending`) {\n      throw `You can no longer call .commit() as the transaction is no longer pending`\n    }\n\n    this.setState(`persisting`)\n\n    if (this.mutations.length === 0) {\n      this.setState(`completed`)\n    }\n\n    // Run mutationFn\n    try {\n      await this.mutationFn({ transaction: this })\n\n      this.setState(`completed`)\n      this.touchCollection()\n\n      this.isPersisted.resolve(this)\n    } catch (error) {\n      // Update transaction with error information\n      this.error = {\n        message: error instanceof Error ? error.message : String(error),\n        error: error instanceof Error ? error : new Error(String(error)),\n      }\n\n      // rollback the transaction\n      return this.rollback()\n    }\n\n    return this\n  }\n}\n"],"names":["createDeferred"],"mappings":"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"}

package/dist/cjs/transactions.d.cts

@@ -0,0 +1,27 @@
+import { Deferred } from './deferred.cjs';
+import { PendingMutation, TransactionConfig, TransactionState } from './types.cjs';
+export declare function createTransaction(config: TransactionConfig): Transaction;
+export declare function getActiveTransaction(): Transaction | undefined;
+export declare class Transaction {
+    id: string;
+    state: TransactionState;
+    mutationFn: import('./types.cjs').MutationFn;
+    mutations: Array<PendingMutation<any>>;
+    isPersisted: Deferred<Transaction>;
+    autoCommit: boolean;
+    createdAt: Date;
+    metadata: Record<string, unknown>;
+    error?: {
+        message: string;
+        error: Error;
+    };
+    constructor(config: TransactionConfig);
+    setState(newState: TransactionState): void;
+    mutate(callback: () => void): Transaction;
+    applyMutations(mutations: Array<PendingMutation<any>>): void;
+    rollback(config?: {
+        isSecondaryRollback?: boolean;
+    }): Transaction;
+    touchCollection(): void;
+    commit(): Promise<Transaction>;
+}

package/dist/cjs/types.d.cts

@@ -0,0 +1,94 @@
+import { Collection } from './collection.cjs';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Transaction } from './transactions.cjs';
+export type TransactionState = `pending` | `persisting` | `completed` | `failed`;
+/**
+ * Represents a pending mutation within a transaction
+ * Contains information about the original and modified data, as well as metadata
+ */
+export interface PendingMutation<T extends object = Record<string, unknown>> {
+    mutationId: string;
+    original: Record<string, unknown>;
+    modified: Record<string, unknown>;
+    changes: Record<string, unknown>;
+    key: string;
+    type: OperationType;
+    metadata: unknown;
+    syncMetadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+    collection: Collection<T>;
+}
+/**
+ * Configuration options for creating a new transaction
+ */
+export type MutationFnParams = {
+    transaction: Transaction;
+};
+export type MutationFn = (params: MutationFnParams) => Promise<any>;
+export interface TransactionConfig {
+    /** Unique identifier for the transaction */
+    id?: string;
+    autoCommit?: boolean;
+    mutationFn: MutationFn;
+    /** Custom metadata to associate with the transaction */
+    metadata?: Record<string, unknown>;
+}
+export type { Transaction };
+type Value<TExtensions = never> = string | number | boolean | bigint | null | TExtensions | Array<Value<TExtensions>> | {
+    [key: string]: Value<TExtensions>;
+};
+export type Row<TExtensions = never> = Record<string, Value<TExtensions>>;
+export type OperationType = `insert` | `update` | `delete`;
+export interface SyncConfig<T extends object = Record<string, unknown>> {
+    sync: (params: {
+        collection: Collection<T>;
+        begin: () => void;
+        write: (message: ChangeMessage<T>) => void;
+        commit: () => void;
+    }) => void;
+    /**
+     * Get the sync metadata for insert operations
+     * @returns Record containing primaryKey and relation information
+     */
+    getSyncMetadata?: () => Record<string, unknown>;
+}
+export interface ChangeMessage<T extends object = Record<string, unknown>> {
+    key: string;
+    value: T;
+    previousValue?: T;
+    type: OperationType;
+    metadata?: Record<string, unknown>;
+}
+export interface OptimisticChangeMessage<T extends object = Record<string, unknown>> extends ChangeMessage<T> {
+    isActive?: boolean;
+}
+/**
+ * The Standard Schema interface.
+ * This follows the standard-schema specification: https://github.com/standard-schema/standard-schema
+ */
+export type StandardSchema<T> = StandardSchemaV1 & {
+    "~standard": {
+        types?: {
+            input: T;
+            output: T;
+        };
+    };
+};
+/**
+ * Type alias for StandardSchema
+ */
+export type StandardSchemaAlias<T = unknown> = StandardSchema<T>;
+export interface OperationConfig {
+    metadata?: Record<string, unknown>;
+}
+export interface InsertConfig {
+    key?: string | Array<string | undefined>;
+    metadata?: Record<string, unknown>;
+}
+export interface CollectionConfig<T extends object = Record<string, unknown>> {
+    id: string;
+    sync: SyncConfig<T>;
+    schema?: StandardSchema<T>;
+}
+export type ChangesPayload<T extends object = Record<string, unknown>> = Array<ChangeMessage<T>>;

package/dist/cjs/utils.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function getLockedObjects() {
+  return /* @__PURE__ */ new Set();
+}
+let globalVersion = 0;
+function getGlobalVersion() {
+  return globalVersion;
+}
+function advanceGlobalVersion() {
+  console.log(`==== advancing global version`, globalVersion + 1);
+  return globalVersion++;
+}
+exports.advanceGlobalVersion = advanceGlobalVersion;
+exports.getGlobalVersion = getGlobalVersion;
+exports.getLockedObjects = getLockedObjects;
+//# sourceMappingURL=utils.cjs.map

package/dist/cjs/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sources":["../../src/utils.ts"],"sourcesContent":["export function getLockedObjects(): Set<string> {\n  // Stub implementation that returns an empty Set\n  return new Set()\n}\n\nlet globalVersion = 0\n\nexport function getGlobalVersion(): number {\n  return globalVersion\n}\n\nexport function advanceGlobalVersion(): number {\n  console.log(`==== advancing global version`, globalVersion + 1)\n  return globalVersion++\n}\n"],"names":[],"mappings":";;AAAO,SAAS,mBAAgC;AAE9C,6BAAW,IAAI;AACjB;AAEA,IAAI,gBAAgB;AAEb,SAAS,mBAA2B;AAClC,SAAA;AACT;AAEO,SAAS,uBAA+B;AACrC,UAAA,IAAI,iCAAiC,gBAAgB,CAAC;AACvD,SAAA;AACT;;;;"}

package/dist/cjs/utils.d.cts

@@ -0,0 +1,3 @@
+export declare function getLockedObjects(): Set<string>;
+export declare function getGlobalVersion(): number;
+export declare function advanceGlobalVersion(): number;

package/dist/esm/SortedMap.d.ts

@@ -0,0 +1,91 @@
+/**
+ * A Map implementation that keeps its entries sorted based on a comparator function
+ * @template TKey - The type of keys in the map
+ * @template TValue - The type of values in the map
+ */
+export declare class SortedMap<TKey, TValue> {
+    private map;
+    private sortedKeys;
+    private comparator;
+    /**
+     * Creates a new SortedMap instance
+     *
+     * @param comparator - Optional function to compare values for sorting
+     */
+    constructor(comparator?: (a: TValue, b: TValue) => number);
+    /**
+     * Default comparator function used when none is provided
+     *
+     * @param a - First value to compare
+     * @param b - Second value to compare
+     * @returns -1 if a < b, 1 if a > b, 0 if equal
+     */
+    private defaultComparator;
+    /**
+     * Sets a key-value pair in the map and maintains sort order
+     *
+     * @param key - The key to set
+     * @param value - The value to associate with the key
+     * @returns This SortedMap instance for chaining
+     */
+    set(key: TKey, value: TValue): this;
+    /**
+     * Gets a value by its key
+     *
+     * @param key - The key to look up
+     * @returns The value associated with the key, or undefined if not found
+     */
+    get(key: TKey): TValue | undefined;
+    /**
+     * Removes a key-value pair from the map
+     *
+     * @param key - The key to remove
+     * @returns True if the key was found and removed, false otherwise
+     */
+    delete(key: TKey): boolean;
+    /**
+     * Checks if a key exists in the map
+     *
+     * @param key - The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    has(key: TKey): boolean;
+    /**
+     * Removes all key-value pairs from the map
+     */
+    clear(): void;
+    /**
+     * Gets the number of key-value pairs in the map
+     */
+    get size(): number;
+    /**
+     * Default iterator that returns entries in sorted order
+     *
+     * @returns An iterator for the map's entries
+     */
+    [Symbol.iterator](): IterableIterator<[TKey, TValue]>;
+    /**
+     * Returns an iterator for the map's entries in sorted order
+     *
+     * @returns An iterator for the map's entries
+     */
+    entries(): IterableIterator<[TKey, TValue]>;
+    /**
+     * Returns an iterator for the map's keys in sorted order
+     *
+     * @returns An iterator for the map's keys
+     */
+    keys(): IterableIterator<TKey>;
+    /**
+     * Returns an iterator for the map's values in sorted order
+     *
+     * @returns An iterator for the map's values
+     */
+    values(): IterableIterator<TValue>;
+    /**
+     * Executes a callback function for each key-value pair in the map in sorted order
+     *
+     * @param callbackfn - Function to execute for each entry
+     */
+    forEach(callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void): void;
+}

package/dist/esm/SortedMap.js

@@ -0,0 +1,140 @@
+class SortedMap {
+  /**
+   * Creates a new SortedMap instance
+   *
+   * @param comparator - Optional function to compare values for sorting
+   */
+  constructor(comparator) {
+    this.map = /* @__PURE__ */ new Map();
+    this.sortedKeys = [];
+    this.comparator = comparator || this.defaultComparator;
+  }
+  /**
+   * Default comparator function used when none is provided
+   *
+   * @param a - First value to compare
+   * @param b - Second value to compare
+   * @returns -1 if a < b, 1 if a > b, 0 if equal
+   */
+  defaultComparator(a, b) {
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+  /**
+   * Sets a key-value pair in the map and maintains sort order
+   *
+   * @param key - The key to set
+   * @param value - The value to associate with the key
+   * @returns This SortedMap instance for chaining
+   */
+  set(key, value) {
+    this.map.set(key, value);
+    if (!this.sortedKeys.includes(key)) {
+      this.sortedKeys.push(key);
+    }
+    this.sortedKeys.sort((a, b) => {
+      const valueA = this.map.get(a);
+      const valueB = this.map.get(b);
+      return this.comparator(valueA, valueB);
+    });
+    return this;
+  }
+  /**
+   * Gets a value by its key
+   *
+   * @param key - The key to look up
+   * @returns The value associated with the key, or undefined if not found
+   */
+  get(key) {
+    return this.map.get(key);
+  }
+  /**
+   * Removes a key-value pair from the map
+   *
+   * @param key - The key to remove
+   * @returns True if the key was found and removed, false otherwise
+   */
+  delete(key) {
+    if (this.map.delete(key)) {
+      const index = this.sortedKeys.indexOf(key);
+      this.sortedKeys.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Checks if a key exists in the map
+   *
+   * @param key - The key to check
+   * @returns True if the key exists, false otherwise
+   */
+  has(key) {
+    return this.map.has(key);
+  }
+  /**
+   * Removes all key-value pairs from the map
+   */
+  clear() {
+    this.map.clear();
+    this.sortedKeys = [];
+  }
+  /**
+   * Gets the number of key-value pairs in the map
+   */
+  get size() {
+    return this.map.size;
+  }
+  /**
+   * Default iterator that returns entries in sorted order
+   *
+   * @returns An iterator for the map's entries
+   */
+  *[Symbol.iterator]() {
+    for (const key of this.sortedKeys) {
+      yield [key, this.map.get(key)];
+    }
+  }
+  /**
+   * Returns an iterator for the map's entries in sorted order
+   *
+   * @returns An iterator for the map's entries
+   */
+  entries() {
+    return this[Symbol.iterator]();
+  }
+  /**
+   * Returns an iterator for the map's keys in sorted order
+   *
+   * @returns An iterator for the map's keys
+   */
+  keys() {
+    return this.sortedKeys[Symbol.iterator]();
+  }
+  /**
+   * Returns an iterator for the map's values in sorted order
+   *
+   * @returns An iterator for the map's values
+   */
+  values() {
+    return (function* () {
+      for (const key of this.sortedKeys) {
+        yield this.map.get(key);
+      }
+    }).call(this);
+  }
+  /**
+   * Executes a callback function for each key-value pair in the map in sorted order
+   *
+   * @param callbackfn - Function to execute for each entry
+   */
+  forEach(callbackfn) {
+    for (const key of this.sortedKeys) {
+      callbackfn(this.map.get(key), key, this.map);
+    }
+  }
+}
+export {
+  SortedMap
+};
+//# sourceMappingURL=SortedMap.js.map

package/dist/esm/SortedMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SortedMap.js","sources":["../../src/SortedMap.ts"],"sourcesContent":["/**\n * A Map implementation that keeps its entries sorted based on a comparator function\n * @template TKey - The type of keys in the map\n * @template TValue - The type of values in the map\n */\nexport class SortedMap<TKey, TValue> {\n  private map: Map<TKey, TValue>\n  private sortedKeys: Array<TKey>\n  private comparator: (a: TValue, b: TValue) => number\n\n  /**\n   * Creates a new SortedMap instance\n   *\n   * @param comparator - Optional function to compare values for sorting\n   */\n  constructor(comparator?: (a: TValue, b: TValue) => number) {\n    this.map = new Map<TKey, TValue>()\n    this.sortedKeys = []\n    this.comparator = comparator || this.defaultComparator\n  }\n\n  /**\n   * Default comparator function used when none is provided\n   *\n   * @param a - First value to compare\n   * @param b - Second value to compare\n   * @returns -1 if a < b, 1 if a > b, 0 if equal\n   */\n  private defaultComparator(a: TValue, b: TValue): number {\n    if (a < b) return -1\n    if (a > b) return 1\n    return 0\n  }\n\n  /**\n   * Sets a key-value pair in the map and maintains sort order\n   *\n   * @param key - The key to set\n   * @param value - The value to associate with the key\n   * @returns This SortedMap instance for chaining\n   */\n  set(key: TKey, value: TValue): this {\n    this.map.set(key, value)\n\n    if (!this.sortedKeys.includes(key)) {\n      this.sortedKeys.push(key)\n    }\n\n    // Re-sort keys based on values\n    this.sortedKeys.sort((a, b) => {\n      const valueA = this.map.get(a)!\n      const valueB = this.map.get(b)!\n      return this.comparator(valueA, valueB)\n    })\n\n    return this\n  }\n\n  /**\n   * Gets a value by its key\n   *\n   * @param key - The key to look up\n   * @returns The value associated with the key, or undefined if not found\n   */\n  get(key: TKey): TValue | undefined {\n    return this.map.get(key)\n  }\n\n  /**\n   * Removes a key-value pair from the map\n   *\n   * @param key - The key to remove\n   * @returns True if the key was found and removed, false otherwise\n   */\n  delete(key: TKey): boolean {\n    if (this.map.delete(key)) {\n      const index = this.sortedKeys.indexOf(key)\n      this.sortedKeys.splice(index, 1)\n      return true\n    }\n    return false\n  }\n\n  /**\n   * Checks if a key exists in the map\n   *\n   * @param key - The key to check\n   * @returns True if the key exists, false otherwise\n   */\n  has(key: TKey): boolean {\n    return this.map.has(key)\n  }\n\n  /**\n   * Removes all key-value pairs from the map\n   */\n  clear(): void {\n    this.map.clear()\n    this.sortedKeys = []\n  }\n\n  /**\n   * Gets the number of key-value pairs in the map\n   */\n  get size(): number {\n    return this.map.size\n  }\n\n  /**\n   * Default iterator that returns entries in sorted order\n   *\n   * @returns An iterator for the map's entries\n   */\n  *[Symbol.iterator](): IterableIterator<[TKey, TValue]> {\n    for (const key of this.sortedKeys) {\n      yield [key, this.map.get(key)!] as [TKey, TValue]\n    }\n  }\n\n  /**\n   * Returns an iterator for the map's entries in sorted order\n   *\n   * @returns An iterator for the map's entries\n   */\n  entries(): IterableIterator<[TKey, TValue]> {\n    return this[Symbol.iterator]()\n  }\n\n  /**\n   * Returns an iterator for the map's keys in sorted order\n   *\n   * @returns An iterator for the map's keys\n   */\n  keys(): IterableIterator<TKey> {\n    return this.sortedKeys[Symbol.iterator]()\n  }\n\n  /**\n   * Returns an iterator for the map's values in sorted order\n   *\n   * @returns An iterator for the map's values\n   */\n  values(): IterableIterator<TValue> {\n    return function* (this: SortedMap<TKey, TValue>) {\n      for (const key of this.sortedKeys) {\n        yield this.map.get(key)!\n      }\n    }.call(this)\n  }\n\n  /**\n   * Executes a callback function for each key-value pair in the map in sorted order\n   *\n   * @param callbackfn - Function to execute for each entry\n   */\n  forEach(\n    callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void\n  ): void {\n    for (const key of this.sortedKeys) {\n      callbackfn(this.map.get(key)!, key, this.map)\n    }\n  }\n}\n"],"names":[],"mappings":"AAKO,MAAM,UAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUnC,YAAY,YAA+C;AACpD,SAAA,0BAAU,IAAkB;AACjC,SAAK,aAAa,CAAC;AACd,SAAA,aAAa,cAAc,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAU/B,kBAAkB,GAAW,GAAmB;AAClD,QAAA,IAAI,EAAU,QAAA;AACd,QAAA,IAAI,EAAU,QAAA;AACX,WAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUT,IAAI,KAAW,OAAqB;AAC7B,SAAA,IAAI,IAAI,KAAK,KAAK;AAEvB,QAAI,CAAC,KAAK,WAAW,SAAS,GAAG,GAAG;AAC7B,WAAA,WAAW,KAAK,GAAG;AAAA,IAAA;AAI1B,SAAK,WAAW,KAAK,CAAC,GAAG,MAAM;AAC7B,YAAM,SAAS,KAAK,IAAI,IAAI,CAAC;AAC7B,YAAM,SAAS,KAAK,IAAI,IAAI,CAAC;AACtB,aAAA,KAAK,WAAW,QAAQ,MAAM;AAAA,IAAA,CACtC;AAEM,WAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAST,IAAI,KAA+B;AAC1B,WAAA,KAAK,IAAI,IAAI,GAAG;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASzB,OAAO,KAAoB;AACzB,QAAI,KAAK,IAAI,OAAO,GAAG,GAAG;AACxB,YAAM,QAAQ,KAAK,WAAW,QAAQ,GAAG;AACpC,WAAA,WAAW,OAAO,OAAO,CAAC;AACxB,aAAA;AAAA,IAAA;AAEF,WAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAST,IAAI,KAAoB;AACf,WAAA,KAAK,IAAI,IAAI,GAAG;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMzB,QAAc;AACZ,SAAK,IAAI,MAAM;AACf,SAAK,aAAa,CAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMrB,IAAI,OAAe;AACjB,WAAO,KAAK,IAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQlB,EAAE,OAAO,QAAQ,IAAsC;AAC1C,eAAA,OAAO,KAAK,YAAY;AACjC,YAAM,CAAC,KAAK,KAAK,IAAI,IAAI,GAAG,CAAE;AAAA,IAAA;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQF,UAA4C;AACnC,WAAA,KAAK,OAAO,QAAQ,EAAE;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ/B,OAA+B;AAC7B,WAAO,KAAK,WAAW,OAAO,QAAQ,EAAE;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ1C,SAAmC;AACjC,YAAO,aAA0C;AACpC,iBAAA,OAAO,KAAK,YAAY;AAC3B,cAAA,KAAK,IAAI,IAAI,GAAG;AAAA,MAAA;AAAA,IACxB,GACA,KAAK,IAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQb,QACE,YACM;AACK,eAAA,OAAO,KAAK,YAAY;AACjC,iBAAW,KAAK,IAAI,IAAI,GAAG,GAAI,KAAK,KAAK,GAAG;AAAA,IAAA;AAAA,EAC9C;AAEJ;"}