@oimdb/core 1.0.0

package/dist/index.js

@@ -0,0 +1,1130 @@
+// src/abstract/OIMCollectionStore.ts
+var OIMCollectionStore = class {
+};
+
+// src/core/OIMEventEmitter.ts
+var OIMEventEmitter = class {
+  constructor() {
+    this.buckets = {};
+  }
+  getOrCreateBucket(event) {
+    let bucket = this.buckets[event];
+    if (!bucket) {
+      bucket = {
+        handlers: [],
+        indexByHandler: /* @__PURE__ */ new Map(),
+        tombstoneCount: 0,
+        isEmitting: 0
+      };
+      this.buckets[event] = bucket;
+    }
+    return bucket;
+  }
+  compactBucket(bucket) {
+    const handlers = bucket.handlers;
+    const length = handlers.length;
+    const newHandlers = [];
+    bucket.indexByHandler.clear();
+    if (bucket.tombstoneCount < length >> 2) {
+      newHandlers.length = length - bucket.tombstoneCount;
+    }
+    let writeIndex = 0;
+    for (let i = 0; i < length; i++) {
+      const handler = handlers[i];
+      if (handler) {
+        newHandlers[writeIndex] = handler;
+        bucket.indexByHandler.set(handler, writeIndex);
+        writeIndex++;
+      }
+    }
+    if (newHandlers.length !== writeIndex) {
+      newHandlers.length = writeIndex;
+    }
+    bucket.handlers = newHandlers;
+    bucket.tombstoneCount = 0;
+  }
+  on(event, handler) {
+    const bucket = this.getOrCreateBucket(event);
+    if (bucket.indexByHandler.has(handler)) return;
+    const index = bucket.handlers.length;
+    bucket.handlers.push(handler);
+    bucket.indexByHandler.set(handler, index);
+  }
+  emit(event, payload) {
+    const bucket = this.buckets[event];
+    if (!bucket) return;
+    const handlers = bucket.handlers;
+    const length = handlers.length;
+    if (length === 0) return;
+    bucket.isEmitting++;
+    for (let i = 0; i < length; i++) {
+      const handler = handlers[i];
+      if (handler) handler(payload);
+    }
+    bucket.isEmitting--;
+    if (bucket.isEmitting === 0 && bucket.tombstoneCount > 0) {
+      if (bucket.tombstoneCount >= length >> 1) {
+        this.compactBucket(bucket);
+      } else if (length === bucket.tombstoneCount) {
+        delete this.buckets[event];
+      }
+    }
+  }
+  off(event, handler) {
+    const bucket = this.buckets[event];
+    if (!bucket) return;
+    const index = bucket.indexByHandler.get(handler);
+    if (index === void 0) return;
+    bucket.handlers[index] = null;
+    bucket.tombstoneCount++;
+    bucket.indexByHandler.delete(handler);
+    if (bucket.isEmitting === 0) {
+      const length = bucket.handlers.length;
+      if (bucket.tombstoneCount >= length >> 1) {
+        this.compactBucket(bucket);
+      } else if (length === bucket.tombstoneCount) {
+        delete this.buckets[event];
+      }
+    }
+  }
+  offAll(event) {
+    if (event !== void 0) {
+      delete this.buckets[event];
+    } else {
+      this.buckets = {};
+    }
+  }
+};
+
+// src/enum/EOIMEventQueueSchedulerEventType.ts
+var EOIMEventQueueSchedulerEventType = /* @__PURE__ */ ((EOIMEventQueueSchedulerEventType2) => {
+  EOIMEventQueueSchedulerEventType2[EOIMEventQueueSchedulerEventType2["FLUSH"] = 0] = "FLUSH";
+  return EOIMEventQueueSchedulerEventType2;
+})(EOIMEventQueueSchedulerEventType || {});
+
+// src/abstract/OIMEventQueueScheduler.ts
+var OIMEventQueueScheduler = class {
+  constructor() {
+    this.emitter = new OIMEventEmitter();
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  /**
+   * Trigger a flush event. Should be called by subclasses when they execute the scheduled flush.
+   */
+  flush() {
+    this.emitter.emit(0 /* FLUSH */, void 0);
+  }
+};
+
+// src/enum/EOIMIndexEventType.ts
+var EOIMIndexEventType = /* @__PURE__ */ ((EOIMIndexEventType2) => {
+  EOIMIndexEventType2[EOIMIndexEventType2["UPDATE"] = 0] = "UPDATE";
+  return EOIMIndexEventType2;
+})(EOIMIndexEventType || {});
+
+// src/abstract/OIMIndex.ts
+var OIMIndex = class {
+  constructor(options = {}) {
+    this.pks = /* @__PURE__ */ new Map();
+    this.emitter = new OIMEventEmitter();
+    this.comparePks = options.comparePks;
+  }
+  /**
+   * Get primary keys for multiple index keys
+   */
+  getPksByKeys(keys) {
+    return new Map(keys.map((key) => [key, this.getPks(key)]));
+  }
+  /**
+   * @deprecated Use getPksByKey instead
+   * Get primary keys for a specific index key
+   */
+  getPks(key) {
+    return this.getPksByKey(key);
+  }
+  /**
+   * Get primary keys for a specific index key
+   */
+  getPksByKey(key) {
+    const pksSet = this.pks.get(key);
+    return pksSet ? Array.from(pksSet) : [];
+  }
+  /**
+   * Check if an index key exists
+   */
+  hasKey(key) {
+    return this.pks.has(key);
+  }
+  /**
+   * Get all index keys
+   */
+  getKeys() {
+    return Array.from(this.pks.keys());
+  }
+  /**
+   * Get the number of primary keys for a specific index key
+   */
+  getKeySize(key) {
+    const pksSet = this.pks.get(key);
+    return pksSet ? pksSet.size : 0;
+  }
+  /**
+   * Get total number of index keys
+   */
+  get size() {
+    return this.pks.size;
+  }
+  /**
+   * Check if the index is empty
+   */
+  get isEmpty() {
+    return this.pks.size === 0;
+  }
+  /**
+   * Get performance metrics for monitoring and debugging
+   */
+  getMetrics() {
+    let totalPks = 0;
+    let maxBucketSize = 0;
+    let minBucketSize = Infinity;
+    for (const pksSet of this.pks.values()) {
+      totalPks += pksSet.size;
+      maxBucketSize = Math.max(maxBucketSize, pksSet.size);
+      minBucketSize = Math.min(minBucketSize, pksSet.size);
+    }
+    return {
+      totalKeys: this.pks.size,
+      totalPks,
+      averagePksPerKey: this.pks.size > 0 ? totalPks / this.pks.size : 0,
+      maxBucketSize: maxBucketSize === -Infinity ? 0 : maxBucketSize,
+      minBucketSize: minBucketSize === Infinity ? 0 : minBucketSize
+    };
+  }
+  /**
+   * Clean up event listeners when index is no longer needed
+   */
+  destroy() {
+    this.emitter.offAll();
+    this.pks.clear();
+  }
+  /**
+   * Set primary keys for a specific index key with optional comparison.
+   * If comparator is provided and returns true (no changes), skip the update.
+   */
+  setPksWithComparison(key, newPks) {
+    const existingPks = this.getPks(key);
+    if (this.comparePks && this.comparePks(existingPks, newPks)) {
+      return false;
+    }
+    this.pks.set(key, new Set(newPks));
+    return true;
+  }
+  /**
+   * Emit update event with changed keys
+   */
+  emitUpdate(keys) {
+    this.emitter.emit(0 /* UPDATE */, { keys });
+  }
+};
+
+// src/enum/EOIMUpdateEventCoalescerEventType.ts
+var EOIMUpdateEventCoalescerEventType = /* @__PURE__ */ ((EOIMUpdateEventCoalescerEventType2) => {
+  EOIMUpdateEventCoalescerEventType2[EOIMUpdateEventCoalescerEventType2["HAS_CHANGES"] = 0] = "HAS_CHANGES";
+  return EOIMUpdateEventCoalescerEventType2;
+})(EOIMUpdateEventCoalescerEventType || {});
+
+// src/core/OIMUpdateEventEmitter.ts
+var OIMUpdateEventEmitter = class {
+  constructor(opts) {
+    this.keyHandlers = /* @__PURE__ */ new Map();
+    this.handleHasChanges = () => {
+      this.queue.enqueue(() => {
+        const updatedKeys = this.coalescer.getUpdatedKeys();
+        if (this.keyHandlers.size === 0) {
+          this.coalescer.clearUpdatedKeys();
+          return;
+        }
+        if (updatedKeys.size * 2 < this.keyHandlers.size) {
+          for (const key of updatedKeys) {
+            const handlers = this.keyHandlers.get(key);
+            if (handlers) {
+              for (const handler of handlers) {
+                handler();
+              }
+            }
+          }
+        } else {
+          for (const [key, handlers] of this.keyHandlers) {
+            if (updatedKeys.has(key)) {
+              for (const handler of handlers) {
+                handler();
+              }
+            }
+          }
+        }
+        this.coalescer.clearUpdatedKeys();
+      });
+    };
+    this.coalescer = opts.coalescer;
+    this.coalescer.emitter.on(
+      0 /* HAS_CHANGES */,
+      this.handleHasChanges
+    );
+    this.queue = opts.queue;
+  }
+  destroy() {
+    this.coalescer.emitter.off(
+      0 /* HAS_CHANGES */,
+      this.handleHasChanges
+    );
+    this.keyHandlers.clear();
+  }
+  /**
+   * Get performance metrics for monitoring and debugging
+   */
+  getMetrics() {
+    let totalHandlers = 0;
+    for (const handlers of this.keyHandlers.values()) {
+      totalHandlers += handlers.size;
+    }
+    return {
+      totalKeys: this.keyHandlers.size,
+      totalHandlers,
+      averageHandlersPerKey: this.keyHandlers.size > 0 ? totalHandlers / this.keyHandlers.size : 0,
+      queueLength: this.queue.length
+    };
+  }
+  /**
+   * Check if there are any active subscriptions
+   */
+  hasSubscriptions() {
+    return this.keyHandlers.size > 0;
+  }
+  /**
+   * Get the number of handlers for a specific key
+   */
+  getHandlerCount(key) {
+    return this.keyHandlers.get(key)?.size ?? 0;
+  }
+  subscribeOnKey(key, handler) {
+    let handlers = this.keyHandlers.get(key);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.keyHandlers.set(key, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      this.unsubscribeFromKey(key, handler);
+    };
+  }
+  unsubscribeFromKey(key, handler) {
+    const handlers = this.keyHandlers.get(key);
+    if (!handlers) return;
+    handlers.delete(handler);
+    if (handlers.size === 0) {
+      this.keyHandlers.delete(key);
+    }
+  }
+  subscribeOnKeys(keys, handler) {
+    const subscribedKeys = [];
+    for (const key of keys) {
+      let handlers = this.keyHandlers.get(key);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Set();
+        this.keyHandlers.set(key, handlers);
+      }
+      if (!handlers.has(handler)) {
+        handlers.add(handler);
+        subscribedKeys.push(key);
+      }
+    }
+    return () => {
+      for (const key of subscribedKeys) {
+        this.unsubscribeFromKey(key, handler);
+      }
+    };
+  }
+  unsubscribeFromKeys(keys, handler) {
+    for (const key of keys) {
+      this.unsubscribeFromKey(key, handler);
+    }
+  }
+};
+
+// src/core/OIMUpdateEventCoalescer.ts
+var OIMUpdateEventCoalescer = class {
+  constructor() {
+    this.emitter = new OIMEventEmitter();
+    this.updatedKeys = /* @__PURE__ */ new Set();
+    this.hasEmittedChanges = false;
+  }
+  /**
+   * Get the set of keys that have been updated since last clear
+   */
+  getUpdatedKeys() {
+    return this.updatedKeys;
+  }
+  /**
+   * Clear all updated keys and reset the changed state
+   */
+  clearUpdatedKeys() {
+    this.updatedKeys.clear();
+    this.hasEmittedChanges = false;
+  }
+  /**
+   * Add keys to the updated set and emit HAS_CHANGES event if needed
+   */
+  addUpdatedKeys(keys) {
+    const hadChanges = this.updatedKeys.size > 0;
+    for (const key of keys) {
+      this.updatedKeys.add(key);
+    }
+    if (!hadChanges && this.updatedKeys.size > 0 && !this.hasEmittedChanges) {
+      this.hasEmittedChanges = true;
+      this.emitter.emit(
+        0 /* HAS_CHANGES */,
+        void 0
+      );
+    }
+  }
+};
+
+// src/core/OIMUpdateEventCoalescerIndex.ts
+var OIMUpdateEventCoalescerIndex = class extends OIMUpdateEventCoalescer {
+  constructor(indexEmitter) {
+    super();
+    this.indexEmitter = indexEmitter;
+    /**
+     * When the index is updated, we keep track of the updated keys.
+     */
+    this.handleUpdate = (payload) => {
+      const hadChanges = this.updatedKeys.size > 0;
+      for (const key of payload.keys) {
+        this.updatedKeys.add(key);
+      }
+      if (!hadChanges && this.updatedKeys.size > 0) {
+        this.emitter.emit(
+          0 /* HAS_CHANGES */,
+          void 0
+        );
+      }
+    };
+    this.indexEmitter.on(0 /* UPDATE */, this.handleUpdate);
+  }
+  destroy() {
+    this.indexEmitter.off(0 /* UPDATE */, this.handleUpdate);
+    this.emitter.offAll();
+    this.updatedKeys.clear();
+  }
+};
+
+// src/abstract/OIMReactiveIndex.ts
+var OIMReactiveIndex = class {
+  constructor(queue, opts) {
+    this.index = opts?.index ?? this.createDefaultIndex();
+    this.coalescer = new OIMUpdateEventCoalescerIndex(
+      this.index.emitter
+    );
+    this.updateEventEmitter = new OIMUpdateEventEmitter({
+      coalescer: this.coalescer,
+      queue
+    });
+  }
+  getPksByKey(key) {
+    return this.index.getPksByKey(key);
+  }
+  getPksByKeys(keys) {
+    return this.index.getPksByKeys(keys);
+  }
+  hasKey(key) {
+    return this.index.hasKey(key);
+  }
+  getKeys() {
+    return this.index.getKeys();
+  }
+  getKeySize(key) {
+    return this.index.getKeySize(key);
+  }
+  get size() {
+    return this.index.size;
+  }
+  get isEmpty() {
+    return this.index.isEmpty;
+  }
+  getMetrics() {
+    return this.index.getMetrics();
+  }
+  destroy() {
+    this.index.destroy();
+  }
+};
+
+// src/core/OIMPkSelectorFactory.ts
+var OIMPkSelectorFactory = class {
+  createIdSelector() {
+    return (entity) => entity.id;
+  }
+};
+
+// src/core/OIMCollectionStoreMapDriven.ts
+var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
+  constructor() {
+    super(...arguments);
+    this.entities = /* @__PURE__ */ new Map();
+  }
+  setOneByPk(pk, entity) {
+    this.entities.set(pk, entity);
+  }
+  setManyByPks(pks, entities) {
+    for (let i = 0; i < pks.length; i++) {
+      this.entities.set(pks[i], entities[i]);
+    }
+  }
+  removeOneByPk(pk) {
+    this.entities.delete(pk);
+  }
+  removeManyByPks(pks) {
+    for (const pk of pks) {
+      this.removeOneByPk(pk);
+    }
+  }
+  getOneByPk(pk) {
+    return this.entities.get(pk);
+  }
+  getManyByPks(pks) {
+    return new Map(pks.map((pk) => [pk, this.getOneByPk(pk)]));
+  }
+};
+
+// src/core/OIMEntityUpdaterFactory.ts
+var OIMEntityUpdaterFactory = class {
+  createMergeEntityUpdater() {
+    return (draft, prev) => {
+      return { ...prev, ...draft };
+    };
+  }
+};
+
+// src/enum/EOIMCollectionEventType.ts
+var EOIMCollectionEventType = /* @__PURE__ */ ((EOIMCollectionEventType2) => {
+  EOIMCollectionEventType2[EOIMCollectionEventType2["UPDATE"] = 0] = "UPDATE";
+  return EOIMCollectionEventType2;
+})(EOIMCollectionEventType || {});
+
+// src/core/OIMCollection.ts
+var OIMCollection = class {
+  constructor(opts) {
+    this.emitter = new OIMEventEmitter();
+    this.selectPk = opts?.selectPk ?? new OIMPkSelectorFactory().createIdSelector();
+    this.store = opts?.store ?? new OIMCollectionStoreMapDriven();
+    this.updateEntity = opts?.updateEntity ?? new OIMEntityUpdaterFactory().createMergeEntityUpdater();
+  }
+  getOneByPk(pk) {
+    return this.store.getOneByPk(pk);
+  }
+  getManyByPks(pks) {
+    return this.store.getManyByPks(pks);
+  }
+  upsertOne(entity) {
+    const pk = this.upsertOneWithoutNotifications(entity);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+  }
+  upsertMany(entities) {
+    const pks = entities.map(
+      (entity) => this.upsertOneWithoutNotifications(entity)
+    );
+    this.emitter.emit(0 /* UPDATE */, { pks });
+  }
+  removeOne(entity) {
+    const pk = this.selectPk(entity);
+    this.store.removeOneByPk(pk);
+    this.emitter.emit(0 /* UPDATE */, { pks: [pk] });
+  }
+  removeMany(entities) {
+    const pks = entities.map(this.selectPk);
+    this.store.removeManyByPks(pks);
+    this.emitter.emit(0 /* UPDATE */, { pks });
+  }
+  upsertOneWithoutNotifications(entity) {
+    const pk = this.selectPk(entity);
+    const existingEntity = this.store.getOneByPk(pk);
+    if (existingEntity) {
+      this.store.setOneByPk(
+        pk,
+        this.updateEntity(entity, existingEntity)
+      );
+    } else {
+      this.store.setOneByPk(pk, entity);
+    }
+    return pk;
+  }
+};
+
+// src/core/OIMUpdateEventCoalescerCollection.ts
+var OIMUpdateEventCoalescerCollection = class extends OIMUpdateEventCoalescer {
+  constructor(collectionEmitter) {
+    super();
+    this.collectionEmitter = collectionEmitter;
+    /**
+     * When the collection is updated, we keep track of the updated pks.
+     */
+    this.handleUpdate = (payload) => {
+      const hadChanges = this.updatedKeys.size > 0;
+      for (const pk of payload.pks) {
+        this.updatedKeys.add(pk);
+      }
+      if (!hadChanges && this.updatedKeys.size > 0) {
+        this.emitter.emit(
+          0 /* HAS_CHANGES */,
+          void 0
+        );
+      }
+    };
+    this.collectionEmitter.on(
+      0 /* UPDATE */,
+      this.handleUpdate
+    );
+  }
+  destroy() {
+    this.collectionEmitter.off(
+      0 /* UPDATE */,
+      this.handleUpdate
+    );
+    this.emitter.offAll();
+    this.updatedKeys.clear();
+  }
+};
+
+// src/core/OIMReactiveCollection.ts
+var OIMReactiveCollection = class {
+  constructor(queue, opts) {
+    this.collection = new OIMCollection(opts?.collectionOpts);
+    this.coalescer = new OIMUpdateEventCoalescerCollection(
+      this.collection.emitter
+    );
+    this.updateEventEmitter = new OIMUpdateEventEmitter({
+      coalescer: this.coalescer,
+      queue
+    });
+  }
+  upsertMany(entities) {
+    this.collection.upsertMany(entities);
+  }
+  upsertOne(entity) {
+    this.collection.upsertOne(entity);
+  }
+  removeMany(entities) {
+    this.collection.removeMany(entities);
+  }
+  removeOne(entity) {
+    this.collection.removeOne(entity);
+  }
+  getOneByPk(pk) {
+    return this.collection.getOneByPk(pk);
+  }
+  getManyByPks(pks) {
+    return this.collection.getManyByPks(pks);
+  }
+};
+
+// src/core/OIMIndexManual.ts
+var OIMIndexManual = class extends OIMIndex {
+  constructor(options = {}) {
+    super(options);
+  }
+  /**
+   * Set primary keys for a specific index key, replacing any existing values.
+   * Uses optional comparator to skip updates if PKs haven't actually changed.
+   */
+  setPks(key, pks) {
+    const hasChanges = this.setPksWithComparison(key, pks);
+    if (hasChanges) {
+      this.emitUpdate([key]);
+    }
+  }
+  /**
+   * Add primary keys to a specific index key
+   */
+  addPks(key, pks) {
+    if (pks.length === 0) return;
+    let pksSet = this.pks.get(key);
+    if (!pksSet) {
+      pksSet = /* @__PURE__ */ new Set();
+      this.pks.set(key, pksSet);
+    }
+    let hasChanges = false;
+    for (const pk of pks) {
+      const sizeBefore = pksSet.size;
+      pksSet.add(pk);
+      if (pksSet.size > sizeBefore) {
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      this.emitUpdate([key]);
+    }
+  }
+  /**
+   * Remove primary keys from a specific index key
+   */
+  removePks(key, pks) {
+    if (pks.length === 0) return;
+    const pksSet = this.pks.get(key);
+    if (!pksSet) return;
+    let hasChanges = false;
+    for (const pk of pks) {
+      if (pksSet.delete(pk)) {
+        hasChanges = true;
+      }
+    }
+    if (pksSet.size === 0) {
+      this.pks.delete(key);
+      hasChanges = true;
+    }
+    if (hasChanges) {
+      this.emitUpdate([key]);
+    }
+  }
+  /**
+   * Clear all primary keys for a specific index key, or all keys if no key specified
+   */
+  clear(key) {
+    if (key === void 0) {
+      if (this.pks.size > 0) {
+        const allKeys = Array.from(this.pks.keys());
+        this.pks.clear();
+        this.emitUpdate(allKeys);
+      }
+    } else {
+      if (this.pks.has(key)) {
+        this.pks.delete(key);
+        this.emitUpdate([key]);
+      }
+    }
+  }
+};
+
+// src/core/OIMReactiveIndexManual.ts
+var OIMReactiveIndexManual = class extends OIMReactiveIndex {
+  constructor(queue, opts) {
+    super(queue, opts);
+  }
+  createDefaultIndex() {
+    return new OIMIndexManual();
+  }
+  setPks(key, pks) {
+    this.index.setPks(key, pks);
+  }
+  addPks(key, pks) {
+    this.index.addPks(key, pks);
+  }
+  removePks(key, pks) {
+    this.index.removePks(key, pks);
+  }
+  clear(key) {
+    this.index.clear(key);
+  }
+};
+
+// src/core/OIMRICollection.ts
+var OIMRICollection = class extends OIMReactiveCollection {
+  constructor(queue, opts) {
+    super(queue, {
+      collectionOpts: opts.collectionOpts
+    });
+    this.indexes = opts.indexes || {};
+  }
+};
+
+// src/core/OIMComparatorFactory.ts
+var OIMComparatorFactory = class {
+  createShallowComparator() {
+    return (a, b) => {
+      if (a === b) return false;
+      const ka = Object.keys(a);
+      const kb = Object.keys(b);
+      if (ka.length !== kb.length) return true;
+      for (let i = 0; i < ka.length; i++) {
+        const k = ka[i];
+        if (b[k] !== a[k])
+          return true;
+      }
+      return false;
+    };
+  }
+};
+
+// src/core/OIMEventQueue.ts
+var OIMEventQueue = class {
+  constructor(options = {}) {
+    this.queue = [];
+    this.scheduler = options.scheduler;
+    if (this.scheduler) {
+      this.flushBound = () => this.flush();
+      this.scheduler.on(
+        0 /* FLUSH */,
+        this.flushBound
+      );
+    }
+  }
+  /**
+   * Add a function to the queue. If scheduler is configured and autoSchedule is enabled,
+   * automatically schedules a flush operation.
+   */
+  enqueue(fn) {
+    this.queue.push(fn);
+    if (this.scheduler && this.queue.length === 1) {
+      this.scheduler.schedule();
+    }
+  }
+  /**
+   * Execute all queued functions and clear the queue.
+   * This method is safe to call multiple times and handles reentrancy.
+   */
+  flush() {
+    if (this.queue.length === 0) return;
+    const currentQueue = this.queue.slice();
+    this.queue.length = 0;
+    for (let i = 0; i < currentQueue.length; i++) {
+      currentQueue[i]();
+    }
+  }
+  /**
+   * Get the current number of queued functions.
+   */
+  get length() {
+    return this.queue.length;
+  }
+  /**
+   * Check if the queue is empty.
+   */
+  get isEmpty() {
+    return this.queue.length === 0;
+  }
+  /**
+   * Clear the queue without executing functions and cancel any scheduled flush.
+   */
+  clear() {
+    this.queue.length = 0;
+    this.scheduler?.cancel();
+  }
+  /**
+   * Clean up scheduler subscription when queue is no longer needed.
+   */
+  destroy() {
+    if (this.scheduler && this.flushBound) {
+      this.scheduler.off(
+        0 /* FLUSH */,
+        this.flushBound
+      );
+    }
+    this.clear();
+  }
+};
+
+// src/core/OIMIndexComparatorFactory.ts
+var OIMIndexComparatorFactory = class {
+  /**
+   * Create an element-wise comparator that checks arrays for strict equality.
+   * Compares array lengths and each element using strict equality (===).
+   */
+  static createElementWiseComparator() {
+    return (existingPks, newPks) => {
+      if (existingPks.length !== newPks.length) {
+        return false;
+      }
+      for (let i = 0; i < existingPks.length; i++) {
+        if (existingPks[i] !== newPks[i]) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+  /**
+   * Create a set-based comparator that checks if arrays contain the same elements.
+   * Order doesn't matter, only the presence of elements.
+   */
+  static createSetBasedComparator() {
+    return (existingPks, newPks) => {
+      if (existingPks.length !== newPks.length) {
+        return false;
+      }
+      const existingSet = new Set(existingPks);
+      const newSet = new Set(newPks);
+      if (existingSet.size !== newSet.size || existingSet.size !== existingPks.length) {
+        return false;
+      }
+      const setValues = Array.from(existingSet);
+      for (let i = 0; i < setValues.length; i++) {
+        const pk = setValues[i];
+        if (!newSet.has(pk)) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+  /**
+   * Create a shallow comparator that only checks array references.
+   * Fastest but only works if you're reusing the same array instances.
+   */
+  static createShallowComparator() {
+    return (existingPks, newPks) => {
+      return existingPks === newPks;
+    };
+  }
+  /**
+   * Create a no-comparison comparator that always returns false (always updates).
+   * Useful for disabling comparison while keeping the same interface.
+   */
+  static createAlwaysUpdateComparator() {
+    return () => false;
+  }
+};
+
+// src/core/OIMMap2Keys.ts
+var OIMMap2Keys = class {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+    this._size = 0;
+  }
+  get size() {
+    return this._size;
+  }
+  set(k1, k2, v) {
+    let m = this.map.get(k1);
+    if (!m) {
+      m = /* @__PURE__ */ new Map();
+      this.map.set(k1, m);
+    }
+    if (!m.has(k2)) this._size++;
+    m.set(k2, v);
+  }
+  get(k1, k2) {
+    return this.map.get(k1)?.get(k2);
+  }
+  has(k1, k2) {
+    return this.map.get(k1)?.has(k2);
+  }
+  delete(k1, k2) {
+    const m = this.map.get(k1);
+    if (!m) return false;
+    const had = m.delete(k2);
+    if (had) {
+      this._size--;
+      if (m.size === 0) this.map.delete(k1);
+    }
+    return had;
+  }
+  clear() {
+    this.map.clear();
+    this._size = 0;
+  }
+};
+
+// src/core/event-queue-scheduler/OIMEventQueueSchedulerAnimationFrame.ts
+var OIMEventQueueSchedulerAnimationFrame = class extends OIMEventQueueScheduler {
+  constructor() {
+    super();
+    this.useRequestAnimationFrame = typeof requestAnimationFrame !== "undefined";
+  }
+  schedule() {
+    if (this.frameId !== void 0) return;
+    if (this.useRequestAnimationFrame) {
+      this.frameId = requestAnimationFrame(() => {
+        this.frameId = void 0;
+        this.flush();
+      });
+    } else {
+      this.frameId = setTimeout(() => {
+        this.frameId = void 0;
+        this.flush();
+      }, 16);
+    }
+  }
+  cancel() {
+    if (this.frameId === void 0) return;
+    if (this.useRequestAnimationFrame) {
+      cancelAnimationFrame(this.frameId);
+    } else {
+      clearTimeout(this.frameId);
+    }
+    this.frameId = void 0;
+  }
+};
+
+// src/core/event-queue-scheduler/OIMEventQueueSchedulerMicrotask.ts
+var OIMEventQueueSchedulerMicrotask = class extends OIMEventQueueScheduler {
+  constructor() {
+    super(...arguments);
+    this.scheduled = false;
+  }
+  schedule() {
+    if (this.scheduled) return;
+    this.scheduled = true;
+    Promise.resolve().then(() => {
+      if (!this.scheduled) return;
+      this.scheduled = false;
+      this.flush();
+    });
+  }
+  cancel() {
+    if (!this.scheduled) return;
+    this.scheduled = false;
+  }
+};
+
+// src/core/event-queue-scheduler/OIMEventQueueSchedulerTimeout.ts
+var OIMEventQueueSchedulerTimeout = class extends OIMEventQueueScheduler {
+  /**
+   * @param delay - Delay in milliseconds before executing the flush (default: 0)
+   */
+  constructor(delay = 0) {
+    super();
+    this.delay = Math.max(0, delay);
+  }
+  schedule() {
+    if (this.timeoutId !== void 0) return;
+    this.timeoutId = setTimeout(() => {
+      this.timeoutId = void 0;
+      this.flush();
+    }, this.delay);
+  }
+  cancel() {
+    if (this.timeoutId === void 0) return;
+    clearTimeout(this.timeoutId);
+    this.timeoutId = void 0;
+  }
+};
+
+// src/core/event-queue-scheduler/OIMEventQueueSchedulerImmediate.ts
+var OIMEventQueueSchedulerImmediate = class extends OIMEventQueueScheduler {
+  constructor() {
+    super();
+    this.useSetImmediate = typeof setImmediate !== "undefined";
+    this.useMessageChannel = !this.useSetImmediate && typeof MessageChannel !== "undefined" && typeof window !== "undefined";
+    if (this.useMessageChannel) {
+      this.messageChannel = new MessageChannel();
+      this.messageChannel.port2.onmessage = () => {
+        if (this.pendingCallback && this.immediateId !== void 0) {
+          const callback = this.pendingCallback;
+          this.pendingCallback = void 0;
+          this.immediateId = void 0;
+          callback();
+        }
+      };
+    }
+  }
+  schedule() {
+    if (this.immediateId !== void 0) return;
+    const callback = () => {
+      this.immediateId = void 0;
+      this.flush();
+    };
+    if (this.useSetImmediate) {
+      this.immediateId = setImmediate(callback);
+    } else if (this.useMessageChannel && this.messageChannel) {
+      this.immediateId = 1;
+      this.pendingCallback = callback;
+      this.messageChannel.port1.postMessage(null);
+    } else {
+      this.immediateId = setTimeout(callback, 0);
+    }
+  }
+  cancel() {
+    if (this.immediateId === void 0) return;
+    if (this.useSetImmediate) {
+      clearImmediate(this.immediateId);
+    } else if (this.useMessageChannel) {
+      this.pendingCallback = void 0;
+    } else {
+      clearTimeout(this.immediateId);
+    }
+    this.immediateId = void 0;
+  }
+};
+
+// src/core/event-queue-scheduler/OIMEventQueueSchedulerFactory.ts
+var OIMEventQueueSchedulerFactory = class {
+  /**
+   * Create a scheduler of the specified type with optional configuration.
+   */
+  static create(type, ...args) {
+    switch (type) {
+      case "microtask":
+        return new OIMEventQueueSchedulerMicrotask();
+      case "animationFrame":
+        return new OIMEventQueueSchedulerAnimationFrame();
+      case "timeout": {
+        const options = args[0];
+        return new OIMEventQueueSchedulerTimeout(options?.delay);
+      }
+      case "immediate":
+        return new OIMEventQueueSchedulerImmediate();
+      default:
+        throw new Error(`Unknown scheduler type: ${type}`);
+    }
+  }
+  /**
+   * Create a microtask scheduler (most common for general use).
+   */
+  static createMicrotask() {
+    return new OIMEventQueueSchedulerMicrotask();
+  }
+  /**
+   * Create an animation frame scheduler (ideal for UI updates).
+   */
+  static createAnimationFrame() {
+    return new OIMEventQueueSchedulerAnimationFrame();
+  }
+  /**
+   * Create a timeout scheduler with optional delay.
+   */
+  static createTimeout(delay) {
+    return new OIMEventQueueSchedulerTimeout(delay);
+  }
+  /**
+   * Create an immediate scheduler (fastest execution).
+   */
+  static createImmediate() {
+    return new OIMEventQueueSchedulerImmediate();
+  }
+};
+export {
+  EOIMCollectionEventType,
+  EOIMEventQueueSchedulerEventType,
+  EOIMIndexEventType,
+  EOIMUpdateEventCoalescerEventType,
+  OIMCollection,
+  OIMCollectionStore,
+  OIMCollectionStoreMapDriven,
+  OIMComparatorFactory,
+  OIMEntityUpdaterFactory,
+  OIMEventEmitter,
+  OIMEventQueue,
+  OIMEventQueueScheduler,
+  OIMEventQueueSchedulerAnimationFrame,
+  OIMEventQueueSchedulerFactory,
+  OIMEventQueueSchedulerImmediate,
+  OIMEventQueueSchedulerMicrotask,
+  OIMEventQueueSchedulerTimeout,
+  OIMIndex,
+  OIMIndexComparatorFactory,
+  OIMIndexManual,
+  OIMMap2Keys,
+  OIMPkSelectorFactory,
+  OIMRICollection,
+  OIMReactiveCollection,
+  OIMReactiveIndex,
+  OIMReactiveIndexManual,
+  OIMUpdateEventCoalescer,
+  OIMUpdateEventCoalescerCollection,
+  OIMUpdateEventCoalescerIndex,
+  OIMUpdateEventEmitter
+};