@signaldb/core 1.0.0 → 1.2.0

package/dist/index2.mjs

@@ -1,632 +1,97 @@
-import EventEmitter from "./index13.mjs";
-import match from "./index14.mjs";
-import modify from "./index10.mjs";
-import isEqual from "./index9.mjs";
-import randomId from "./index11.mjs";
-import deepClone from "./index15.mjs";
-import serializeValue from "./index16.mjs";
-import createSignal from "./index17.mjs";
-import Cursor from "./index18.mjs";
-import getIndexInfo from "./index19.mjs";
-import { createExternalIndex } from "./index12.mjs";
-import { default as default2 } from "./index12.mjs";
-function hasPendingUpdates(pendingUpdates) {
-  return pendingUpdates.added.length > 0 || pendingUpdates.modified.length > 0 || pendingUpdates.removed.length > 0;
+import Collection from "./index3.mjs";
+/* istanbul ignore file -- @preserve */
+const devtoolsInProductionWarning = `
+
+
+[@signaldb/core] !! WARNING !!
+You are running @signaldb/devtools in production mode.
+This can have a negative impact on performance and may expose sensitive information.
+Please move @signaldb/devtools to development dependencies to disable it in production.
+
+
+`;
+function isNodeErrorWithCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string";
 }
-function applyUpdates(currentItems, { added, modified, removed }) {
-  const items = currentItems.slice();
-  added.forEach((item) => {
-    items.push(item);
-  });
-  modified.forEach((item) => {
-    const index = items.findIndex(({ id }) => id === item.id);
-    if (index === -1)
-      return;
-    items[index] = item;
-  });
-  removed.forEach((item) => {
-    const index = items.findIndex(({ id }) => id === item.id);
-    if (index === -1)
-      return;
-    items.splice(index, 1);
-  });
-  return items;
+function isCommonJS() {
+  return typeof module !== "undefined" && !!module.exports;
 }
-class Collection extends EventEmitter {
-  /**
-   * Executes a batch operation, allowing multiple modifications to the collection
-   * while deferring index rebuilding until all operations in the batch are completed.
-   * This improves performance by avoiding repetitive index recalculations and
-   * provides atomicity for the batch of operations.
-   * @param callback - The batch operation to execute.
-   */
-  static batch(callback) {
-    Collection.batchOperationInProgress = true;
-    Collection.collections.reduce((memo, collection) => () => collection.batch(() => memo()), callback)();
-    Collection.batchOperationInProgress = false;
-  }
-  /**
-   * Initializes a new instance of the `Collection` class with optional configuration.
-   * Sets up memory, persistence, reactivity, and indices as specified in the options.
-   * @template T - The type of the items stored in the collection.
-   * @template I - The type of the unique identifier for the items.
-   * @template U - The transformed item type after applying transformations (default is T).
-   * @param options - Optional configuration for the collection.
-   * @param options.memory - The in-memory adapter for storing items.
-   * @param options.reactivity - The reactivity adapter for observing changes in the collection.
-   * @param options.transform - A transformation function to apply to items when retrieving them.
-   * @param options.persistence - The persistence adapter for saving and loading items.
-   * @param options.indices - An array of index providers for optimized querying.
-   * @param options.enableDebugMode - A boolean to enable or disable debug mode.
-   * @param options.fieldTracking - A boolean to enable or disable field tracking by default.
-   */
-  constructor(options) {
-    var _a, _b, _c, _d, _e;
-    super();
-    this.persistenceAdapter = null;
-    this.indexProviders = [];
-    this.indicesOutdated = false;
-    this.idIndex = /* @__PURE__ */ new Map();
-    this.batchOperationInProgress = false;
-    this.isDisposed = false;
-    this.postBatchCallbacks = /* @__PURE__ */ new Set();
-    this.fieldTracking = false;
-    Collection.collections.push(this);
-    this.options = Object.assign({ memory: [] }, options);
-    this.fieldTracking = (_a = this.options.fieldTracking) !== null && _a !== void 0 ? _a : Collection.fieldTracking;
-    this.debugMode = (_b = this.options.enableDebugMode) !== null && _b !== void 0 ? _b : Collection.debugMode;
-    this.indexProviders = [
-      createExternalIndex("id", this.idIndex),
-      ...this.options.indices || []
-    ];
-    this.rebuildIndices();
-    this.isPullingSignal = createSignal((_c = this.options.reactivity) === null || _c === void 0 ? void 0 : _c.create(), !!(options === null || options === void 0 ? void 0 : options.persistence));
-    this.isPushingSignal = createSignal((_d = this.options.reactivity) === null || _d === void 0 ? void 0 : _d.create(), false);
-    this.on("persistence.pullStarted", () => {
-      this.isPullingSignal.set(true);
-    });
-    this.on("persistence.pullCompleted", () => {
-      this.isPullingSignal.set(false);
-    });
-    this.on("persistence.pushStarted", () => {
-      this.isPushingSignal.set(true);
-    });
-    this.on("persistence.pushCompleted", () => {
-      this.isPushingSignal.set(false);
-    });
-    this.persistenceAdapter = (_e = this.options.persistence) !== null && _e !== void 0 ? _e : null;
-    if (this.persistenceAdapter) {
-      let ongoingSaves = 0;
-      let isInitialized = false;
-      const pendingUpdates = { added: [], modified: [], removed: [] };
-      const loadPersistentData = async (data) => {
-        if (!this.persistenceAdapter)
-          throw new Error("Persistence adapter not found");
-        this.emit("persistence.pullStarted");
-        const { items, changes } = data !== null && data !== void 0 ? data : await this.persistenceAdapter.load();
-        if (items) {
-          if (ongoingSaves > 0)
-            return;
-          this.memory().splice(0, this.memoryArray().length, ...items);
-          this.idIndex.clear();
-          this.memory().map((item, index) => {
-            this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([index]));
-          });
-        } else if (changes) {
-          changes.added.forEach((item) => {
-            const index = this.memory().findIndex((doc) => doc.id === item.id);
-            if (index >= 0) {
-              this.memory().splice(index, 1, item);
-              return;
-            }
-            this.memory().push(item);
-            const itemIndex = this.memory().findIndex((doc) => doc === item);
-            this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([itemIndex]));
-          });
-          changes.modified.forEach((item) => {
-            const index = this.memory().findIndex((doc) => doc.id === item.id);
-            if (index === -1)
-              throw new Error("Cannot resolve index for item");
-            this.memory().splice(index, 1, item);
-          });
-          changes.removed.forEach((item) => {
-            const index = this.memory().findIndex((doc) => doc.id === item.id);
-            if (index === -1)
-              throw new Error("Cannot resolve index for item");
-            this.memory().splice(index, 1);
-          });
-        }
-        this.rebuildIndices();
-        this.emit("persistence.received");
-        setTimeout(() => this.emit("persistence.pullCompleted"), 0);
-      };
-      const saveQueue = {
-        added: [],
-        modified: [],
-        removed: []
-      };
-      let isFlushing = false;
-      const flushQueue = () => {
-        if (!this.persistenceAdapter)
-          throw new Error("Persistence adapter not found");
-        if (ongoingSaves <= 0)
-          this.emit("persistence.pushStarted");
-        if (isFlushing)
-          return;
-        if (!hasPendingUpdates(saveQueue))
-          return;
-        isFlushing = true;
-        ongoingSaves += 1;
-        const currentItems = this.memoryArray();
-        const changes = Object.assign({}, saveQueue);
-        saveQueue.added = [];
-        saveQueue.modified = [];
-        saveQueue.removed = [];
-        this.persistenceAdapter.save(currentItems, changes).then(() => {
-          this.emit("persistence.transmitted");
-        }).catch((error) => {
-          this.emit("persistence.error", error instanceof Error ? error : new Error(error));
-        }).finally(() => {
-          ongoingSaves -= 1;
-          isFlushing = false;
-          flushQueue();
-          if (ongoingSaves <= 0)
-            this.emit("persistence.pushCompleted");
-        });
-      };
-      this.on("added", (item) => {
-        if (!isInitialized) {
-          pendingUpdates.added.push(item);
-          return;
-        }
-        saveQueue.added.push(item);
-        flushQueue();
-      });
-      this.on("changed", (item) => {
-        if (!isInitialized) {
-          pendingUpdates.modified.push(item);
-          return;
-        }
-        saveQueue.modified.push(item);
-        flushQueue();
-      });
-      this.on("removed", (item) => {
-        if (!isInitialized) {
-          pendingUpdates.removed.push(item);
-          return;
-        }
-        saveQueue.removed.push(item);
-        flushQueue();
-      });
-      this.persistenceAdapter.register((data) => loadPersistentData(data)).then(async () => {
-        if (!this.persistenceAdapter)
-          throw new Error("Persistence adapter not found");
-        let currentItems = this.memoryArray();
-        await loadPersistentData();
-        while (hasPendingUpdates(pendingUpdates)) {
-          const added = pendingUpdates.added.splice(0);
-          const modified = pendingUpdates.modified.splice(0);
-          const removed = pendingUpdates.removed.splice(0);
-          currentItems = applyUpdates(this.memoryArray(), { added, modified, removed });
-          await this.persistenceAdapter.save(currentItems, { added, modified, removed }).then(() => {
-            this.emit("persistence.transmitted");
-          });
-        }
-        await loadPersistentData();
-        isInitialized = true;
-        setTimeout(() => this.emit("persistence.init"), 0);
-      }).catch((error) => {
-        this.emit("persistence.error", error instanceof Error ? error : new Error(error));
-      });
+async function checkDevtoolsAvailability() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  if (isCommonJS()) {
+    try {
+      require.resolve("@signaldb/devtools");
+      return true;
+    } catch {
+      return false;
     }
   }
-  /**
-   * Checks whether the collection is currently performing a pull operation
-   * ⚡️ this function is reactive!
-   * (loading data from the persistence adapter).
-   * @returns A boolean indicating if the collection is in the process of pulling data.
-   */
-  isPulling() {
-    var _a;
-    return (_a = this.isPullingSignal.get()) !== null && _a !== void 0 ? _a : false;
-  }
-  /**
-   * Checks whether the collection is currently performing a push operation
-   * ⚡️ this function is reactive!
-   * (saving data to the persistence adapter).
-   * @returns A boolean indicating if the collection is in the process of pushing data.
-   */
-  isPushing() {
-    var _a;
-    return (_a = this.isPushingSignal.get()) !== null && _a !== void 0 ? _a : false;
-  }
-  /**
-   * Checks whether the collection is currently performing either a pull or push operation,
-   * ⚡️ this function is reactive!
-   * indicating that it is loading or saving data.
-   * @returns A boolean indicating if the collection is in the process of loading or saving data.
-   */
-  isLoading() {
-    const isPulling = this.isPulling();
-    const isPushing = this.isPushing();
-    return isPulling || isPushing;
-  }
-  /**
-   * Retrieves the current debug mode status of the collection.
-   * @returns A boolean indicating whether debug mode is enabled for the collection.
-   */
-  getDebugMode() {
-    return this.debugMode;
-  }
-  /**
-   * Enables or disables debug mode for the collection.
-   * When debug mode is enabled, additional debugging information and events are emitted.
-   * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) debug mode.
-   */
-  setDebugMode(enable) {
-    this.debugMode = enable;
-  }
-  /**
-   * Enables or disables field tracking for the collection.
-   * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) field tracking.
-   */
-  setFieldTracking(enable) {
-    this.fieldTracking = enable;
-  }
-  profile(fn, measureFunction) {
-    if (!this.debugMode)
-      return fn();
-    const startTime = performance.now();
-    const result = fn();
-    const endTime = performance.now();
-    measureFunction(endTime - startTime);
-    return result;
-  }
-  executeInDebugMode(fn) {
-    if (!this.debugMode)
-      return;
-    const callstack = new Error().stack || "";
-    fn(callstack);
-  }
-  rebuildIndices() {
-    this.indicesOutdated = true;
-    if (this.batchOperationInProgress)
-      return;
-    this.rebuildAllIndices();
-  }
-  rebuildAllIndices() {
-    this.idIndex.clear();
-    this.memory().map((item, index) => {
-      this.idIndex.set(serializeValue(item.id), /* @__PURE__ */ new Set([index]));
-    });
-    this.indexProviders.forEach((index) => index.rebuild(this.memoryArray()));
-    this.indicesOutdated = false;
-  }
-  getIndexInfo(selector) {
-    if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
-      return {
-        matched: true,
-        positions: Array.from(this.idIndex.get(serializeValue(selector.id)) || []),
-        optimizedSelector: {}
-      };
+  try {
+    await import("@signaldb/devtools");
+    return true;
+  } catch (error) {
+    if (!isNodeErrorWithCode(error) || error.code !== "MODULE_NOT_FOUND") {
+      throw error;
     }
-    if (selector == null || this.indicesOutdated) {
-      return {
-        matched: false,
-        positions: [],
-        optimizedSelector: {}
-      };
-    }
-    return getIndexInfo(this.indexProviders, selector);
   }
-  getItemAndIndex(selector) {
-    const memory = this.memoryArray();
-    const indexInfo = this.getIndexInfo(selector);
-    const items = indexInfo.matched ? indexInfo.positions.map((index2) => memory[index2]) : memory;
-    const item = items.find((doc) => match(doc, selector));
-    const index = indexInfo.matched && indexInfo.positions.find((itemIndex) => memory[itemIndex] === item) || memory.findIndex((doc) => doc === item);
-    if (item == null)
-      return { item: null, index: -1 };
-    if (index === -1)
-      throw new Error("Cannot resolve index for item");
-    return { item, index };
+  try {
+    const modulePackage = await import("./index15.mjs");
+    const createRequireFunction = modulePackage.default.createRequire;
+    const cjsRequire = createRequireFunction(import.meta.url);
+    cjsRequire.resolve("@signaldb/devtools");
+    return true;
+  } catch {
+    return false;
   }
-  deleteFromIdIndex(id, index) {
-    this.idIndex.delete(serializeValue(id));
-    if (!this.batchOperationInProgress)
-      return;
-    this.idIndex.forEach(([currenIndex], key) => {
-      if (currenIndex > index) {
-        this.idIndex.set(key, /* @__PURE__ */ new Set([currenIndex - 1]));
+}
+async function checkAndImportDevtools() {
+  const available = await checkDevtoolsAvailability();
+  if (!available)
+    return false;
+  if (isCommonJS()) {
+    try {
+      require("@signaldb/devtools");
+      return true;
+    } catch (error) {
+      if (isNodeErrorWithCode(error) && error.code === "MODULE_NOT_FOUND") {
+        return false;
       }
-    });
-  }
-  memory() {
-    return this.options.memory;
-  }
-  memoryArray() {
-    return this.memory().map((item) => item);
-  }
-  transform(item) {
-    if (!this.options.transform)
-      return item;
-    return this.options.transform(item);
-  }
-  getItems(selector) {
-    return this.profile(() => {
-      const indexInfo = this.getIndexInfo(selector);
-      const matchItems = (item) => {
-        if (indexInfo.optimizedSelector == null)
-          return true;
-        if (Object.keys(indexInfo.optimizedSelector).length <= 0)
-          return true;
-        const matches = match(item, indexInfo.optimizedSelector);
-        return matches;
-      };
-      if (!indexInfo.matched)
-        return this.memory().filter(matchItems);
-      const memory = this.memoryArray();
-      const items = indexInfo.positions.map((index) => memory[index]);
-      this.emit("getItems", selector);
-      return items.filter(matchItems);
-    }, (measuredTime) => this.executeInDebugMode((callstack) => this.emit("_debug.getItems", callstack, selector, measuredTime)));
-  }
-  /**
-   * Disposes the collection, unregisters persistence adapters, clears memory, and
-   * cleans up all resources used by the collection.
-   * @returns A promise that resolves when the collection is disposed.
-   */
-  async dispose() {
-    var _a;
-    if ((_a = this.persistenceAdapter) === null || _a === void 0 ? void 0 : _a.unregister)
-      await this.persistenceAdapter.unregister();
-    this.persistenceAdapter = null;
-    this.memory().map(() => this.memory().pop());
-    this.idIndex.clear();
-    this.indexProviders = [];
-    this.isDisposed = true;
-  }
-  /**
-   * Finds multiple items in the collection based on a selector and optional options.
-   * Returns a cursor for reactive data queries.
-   * @template O - The options type for the find operation.
-   * @param [selector] - The criteria to select items.
-   * @param [options] - Options for the find operation, such as limit and sort.
-   * @returns A cursor to fetch and observe the matching items.
-   */
-  find(selector, options) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (selector !== void 0 && (!selector || typeof selector !== "object"))
-      throw new Error("Invalid selector");
-    const cursor = new Cursor(() => this.getItems(selector), Object.assign(Object.assign({ reactive: this.options.reactivity, fieldTracking: this.fieldTracking }, options), { transform: this.transform.bind(this), bindEvents: (requery) => {
-      const handleRequery = () => {
-        if (this.batchOperationInProgress) {
-          this.postBatchCallbacks.add(requery);
-          return;
-        }
-        requery();
-      };
-      this.addListener("persistence.received", handleRequery);
-      this.addListener("added", handleRequery);
-      this.addListener("changed", handleRequery);
-      this.addListener("removed", handleRequery);
-      this.emit("observer.created", selector, options);
-      return () => {
-        this.removeListener("persistence.received", handleRequery);
-        this.removeListener("added", handleRequery);
-        this.removeListener("changed", handleRequery);
-        this.removeListener("removed", handleRequery);
-        this.emit("observer.disposed", selector, options);
-      };
-    } }));
-    this.emit("find", selector, options, cursor);
-    this.executeInDebugMode((callstack) => this.emit("_debug.find", callstack, selector, options, cursor));
-    return cursor;
-  }
-  /**
-   * Finds a single item in the collection based on a selector and optional options.
-   * ⚡️ this function is reactive!
-   * Returns the found item or undefined if no item matches.
-   * @template O - The options type for the find operation.
-   * @param selector - The criteria to select the item.
-   * @param [options] - Options for the find operation, such as projection.
-   * @returns The found item or `undefined`.
-   */
-  findOne(selector, options) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    const cursor = this.find(selector, Object.assign({ limit: 1 }, options));
-    const returnValue = cursor.fetch()[0] || void 0;
-    this.emit("findOne", selector, options, returnValue);
-    this.executeInDebugMode((callstack) => this.emit("_debug.findOne", callstack, selector, options, returnValue));
-    return returnValue;
-  }
-  /**
-   * Performs a batch operation, deferring index rebuilds and allowing multiple
-   * modifications to be made atomically. Executes any post-batch callbacks afterwards.
-   * @param callback - The batch operation to execute.
-   */
-  batch(callback) {
-    this.batchOperationInProgress = true;
-    callback();
-    this.batchOperationInProgress = false;
-    this.rebuildAllIndices();
-    this.postBatchCallbacks.forEach((cb) => cb());
-    this.postBatchCallbacks.clear();
-  }
-  /**
-   * Inserts a single item into the collection. Generates a unique ID if not provided.
-   * @param item - The item to insert.
-   * @returns The ID of the inserted item.
-   * @throws {Error} If the collection is disposed or the item has an invalid ID.
-   */
-  insert(item) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!item)
-      throw new Error("Invalid item");
-    const newItem = Object.assign({ id: randomId() }, item);
-    if (this.idIndex.has(serializeValue(newItem.id)))
-      throw new Error("Item with same id already exists");
-    this.memory().push(newItem);
-    const itemIndex = this.memory().findIndex((doc) => doc === newItem);
-    this.idIndex.set(serializeValue(newItem.id), /* @__PURE__ */ new Set([itemIndex]));
-    this.rebuildIndices();
-    this.emit("added", newItem);
-    this.emit("insert", newItem);
-    this.executeInDebugMode((callstack) => this.emit("_debug.insert", callstack, newItem));
-    return newItem.id;
-  }
-  /**
-   * Inserts multiple items into the collection. Generates unique IDs for items if not provided.
-   * @param items - The items to insert.
-   * @returns An array of IDs of the inserted items.
-   * @throws {Error} If the collection is disposed or the items are invalid.
-   */
-  insertMany(items) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!items)
-      throw new Error("Invalid items");
-    if (items.length === 0) {
-      return [];
+      throw error;
     }
-    const ids = [];
-    this.batch(() => {
-      items.forEach((item) => {
-        ids.push(this.insert(item));
-      });
-    });
-    return ids;
-  }
-  /**
-   * Updates a single item in the collection that matches the given selector.
-   * @param selector - The criteria to select the item to update.
-   * @param modifier - The modifications to apply to the item.
-   * @returns The number of items updated (0 or 1).
-   * @throws {Error} If the collection is disposed or invalid arguments are provided.
-   */
-  updateOne(selector, modifier) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!selector)
-      throw new Error("Invalid selector");
-    if (!modifier)
-      throw new Error("Invalid modifier");
-    const { item, index } = this.getItemAndIndex(selector);
-    if (item == null)
-      return 0;
-    const modifiedItem = modify(deepClone(item), modifier);
-    const existingItem = this.findOne({ id: modifiedItem.id }, { reactive: false });
-    if (!isEqual(existingItem, Object.assign(Object.assign({}, existingItem), { id: modifiedItem.id })))
-      throw new Error("Item with same id already exists");
-    this.memory().splice(index, 1, modifiedItem);
-    this.rebuildIndices();
-    this.emit("changed", modifiedItem, modifier);
-    this.emit("updateOne", selector, modifier);
-    this.executeInDebugMode((callstack) => this.emit("_debug.updateOne", callstack, selector, modifier));
-    return 1;
-  }
-  /**
-   * Updates multiple items in the collection that match the given selector.
-   * @param selector - The criteria to select the items to update.
-   * @param modifier - The modifications to apply to the items.
-   * @returns The number of items updated.
-   * @throws {Error} If the collection is disposed or invalid arguments are provided.
-   */
-  updateMany(selector, modifier) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!selector)
-      throw new Error("Invalid selector");
-    if (!modifier)
-      throw new Error("Invalid modifier");
-    const items = this.getItems(selector);
-    const modifiedItems = [];
-    items.forEach((item) => {
-      const { index } = this.getItemAndIndex({ id: item.id });
-      if (index === -1)
-        throw new Error("Cannot resolve index for item");
-      const modifiedItem = modify(deepClone(item), modifier);
-      this.memory().splice(index, 1, modifiedItem);
-      modifiedItems.push(modifiedItem);
-    });
-    this.rebuildIndices();
-    modifiedItems.forEach((modifiedItem) => {
-      this.emit("changed", modifiedItem, modifier);
-    });
-    this.emit("updateMany", selector, modifier);
-    this.executeInDebugMode((callstack) => this.emit("_debug.updateMany", callstack, selector, modifier));
-    return modifiedItems.length;
   }
-  /**
-   * Removes a single item from the collection that matches the given selector.
-   * @param selector - The criteria to select the item to remove.
-   * @returns The number of items removed (0 or 1).
-   * @throws {Error} If the collection is disposed or invalid arguments are provided.
-   */
-  removeOne(selector) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!selector)
-      throw new Error("Invalid selector");
-    const { item, index } = this.getItemAndIndex(selector);
-    if (item != null) {
-      this.memory().splice(index, 1);
-      this.deleteFromIdIndex(item.id, index);
-      this.rebuildIndices();
-      this.emit("removed", item);
+  try {
+    await import("@signaldb/devtools");
+    return true;
+  } catch (error) {
+    if (!isNodeErrorWithCode(error) || error.code !== "MODULE_NOT_FOUND") {
+      throw error;
     }
-    this.emit("removeOne", selector);
-    this.executeInDebugMode((callstack) => this.emit("_debug.removeOne", callstack, selector));
-    return item == null ? 0 : 1;
   }
-  /**
-   * Removes multiple items from the collection that match the given selector.
-   * @param selector - The criteria to select the items to remove.
-   * @returns The number of items removed.
-   * @throws {Error} If the collection is disposed or invalid arguments are provided.
-   */
-  removeMany(selector) {
-    if (this.isDisposed)
-      throw new Error("Collection is disposed");
-    if (!selector)
-      throw new Error("Invalid selector");
-    const items = this.getItems(selector);
-    items.forEach((item) => {
-      const index = this.memory().findIndex((doc) => doc === item);
-      if (index === -1)
-        throw new Error("Cannot resolve index for item");
-      this.memory().splice(index, 1);
-      this.deleteFromIdIndex(item.id, index);
-      this.rebuildIndices();
-    });
-    items.forEach((item) => {
-      this.emit("removed", item);
-    });
-    this.emit("removeMany", selector);
-    this.executeInDebugMode((callstack) => this.emit("_debug.removeMany", callstack, selector));
-    return items.length;
+  try {
+    const modulePackage = await import("./index15.mjs");
+    const createRequireFunction = modulePackage.default.createRequire;
+    const cjsRequire = createRequireFunction(import.meta.url);
+    cjsRequire("@signaldb/devtools");
+    return true;
+  } catch (error) {
+    if (isNodeErrorWithCode(error) && error.code === "MODULE_NOT_FOUND") {
+      return false;
+    }
+    throw error;
   }
 }
-Collection.collections = [];
-Collection.debugMode = false;
-Collection.batchOperationInProgress = false;
-Collection.fieldTracking = false;
-Collection.enableDebugMode = () => {
-  Collection.debugMode = true;
-  Collection.collections.forEach((collection) => {
-    collection.setDebugMode(true);
-  });
-};
-Collection.setFieldTracking = (enable) => {
-  Collection.fieldTracking = enable;
-  Collection.collections.forEach((collection) => {
-    collection.setFieldTracking(enable);
+function loadDeveloperTools() {
+  const isProduction = process.env.NODE_ENV === "production";
+  void checkAndImportDevtools().then((devtoolsLoaded) => {
+    if (!devtoolsLoaded)
+      return;
+    Collection.enableDebugMode();
+    if (isProduction)
+      console.warn(devtoolsInProductionWarning);
   });
-};
+}
 export {
-  default2 as createIndex,
-  Collection as default
+  loadDeveloperTools as default
 };