@signaldb/core 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/index16.mjs

@@ -1,571 +1,136 @@
-import deepClone from "./index19.mjs";
-import match from "./index22.mjs";
-import modify from "./index7.mjs";
-import queryId from "./index24.mjs";
-import isEqual from "./index6.mjs";
-import getIndexInfo from "./index21.mjs";
-import getMatchingKeys from "./index26.mjs";
-import sortItems from "./index25.mjs";
-import project from "./index23.mjs";
-function defaultMergeItems(a, b) {
-  return { ...a, ...b };
+import intersection from "./index15.mjs";
+//#region src/getIndexInfo.ts
+/**
+* Retrieves merged index information for a given flat selector by querying multiple
+* index providers. Combines results from all index providers to determine matched ids
+* and an optimized selector.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param queryFunctions - An array of index providers to query.
+* @param selector - The flat selector used to filter items.
+* @returns An object containing:
+*   - `matched`: A boolean indicating if the selector matched any items.
+*   - `ids`: An array of matched item ids.
+*   - `optimizedSelector`: A flat selector optimized based on the index results.
+*/
+function getMergedIndexInfo(queryFunctions, selector) {
+	return queryFunctions.reduce((memoOrPromise, queryFunction) => {
+		const resultOrPromise = queryFunction(selector);
+		const processResult = (memo, result) => {
+			if (!result.matched) return memo;
+			const optimizedSelector = result.keepSelector ? memo.optimizedSelector : Object.fromEntries(Object.entries(memo.optimizedSelector).filter(([key]) => !result.fields.includes(key)));
+			return {
+				matched: true,
+				ids: [...new Set(memo.matched ? intersection(memo.ids, result.ids) : result.ids)],
+				optimizedSelector
+			};
+		};
+		if (resultOrPromise instanceof Promise) return resultOrPromise.then(async (result) => {
+			return processResult(memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise, result);
+		});
+		const memo = memoOrPromise;
+		if (memo instanceof Promise) throw new Error("Mixing async and sync index providers is not supported");
+		return processResult(memo, resultOrPromise);
+	}, {
+		matched: false,
+		ids: [],
+		optimizedSelector: { ...selector }
+	});
 }
-class AutoFetchDataAdapter {
-  options;
-  id;
-  onError;
-  fetchQueryItems;
-  mergeItems;
-  purgeDelay;
-  // Per-collection resources
-  storageAdapters = /* @__PURE__ */ new Map();
-  storageAdapterReady = /* @__PURE__ */ new Map();
-  collectionIndices = /* @__PURE__ */ new Map();
-  // Per-collection query registries and auto-fetch bookkeeping
-  queries = /* @__PURE__ */ new Map();
-  activeObservers = /* @__PURE__ */ new Map();
-  // per-collection: key->record
-  observerTimeouts = /* @__PURE__ */ new Map();
-  // per-collection
-  selectorIds = /* @__PURE__ */ new Map();
-  // per-collection: selectorKey -> Set<id>
-  idRefCounts = /* @__PURE__ */ new Map();
-  // per-collection: id -> refcount (for auto-fetched items)
-  autoloadIds = /* @__PURE__ */ new Map();
-  // per-collection: ids that were introduced via auto-fetch
-  constructor(options) {
-    this.options = options;
-    this.id = options.id || "autofetch-data-adapter";
-    this.onError = options.onError ?? ((error) => {
-      console.error(error);
-    });
-    this.fetchQueryItems = options.fetchQueryItems;
-    this.mergeItems = options.mergeItems ?? defaultMergeItems;
-    this.purgeDelay = options.purgeDelay ?? 1e4;
-    if (options.registerRemoteChange) {
-      void options.registerRemoteChange(async () => {
-        await this.forceRefetchAll();
-      });
-    }
-  }
-  createCollectionBackend(collection, indices) {
-    this.collectionIndices.set(collection.name, indices);
-    this.queries.set(collection.name, /* @__PURE__ */ new Map());
-    this.ensureStorageAdapter(collection.name);
-    this.activeObservers.set(collection.name, /* @__PURE__ */ new Map());
-    this.observerTimeouts.set(collection.name, /* @__PURE__ */ new Map());
-    this.selectorIds.set(collection.name, /* @__PURE__ */ new Map());
-    this.idRefCounts.set(collection.name, /* @__PURE__ */ new Map());
-    this.autoloadIds.set(collection.name, /* @__PURE__ */ new Set());
-    const ready = this.setupStorage(collection.name, indices);
-    this.storageAdapterReady.set(collection.name, ready);
-    const registerQuery = (selector, options) => {
-      const qid = queryId(selector, options);
-      const registry = this.queries.get(collection.name);
-      if (!registry)
-        throw new Error(`Collection ${collection.name} not initialized!`);
-      registry.set(qid, {
-        selector,
-        options,
-        items: [],
-        listeners: /* @__PURE__ */ new Set(),
-        ...registry.get(qid),
-        state: "active",
-        error: null
-      });
-      const key = this.selectorKey(selector);
-      const perColObservers = this.activeObservers.get(collection.name);
-      const current = perColObservers?.get(key)?.count ?? 0;
-      perColObservers?.set(key, { selector, count: current + 1 });
-      const timeouts = this.observerTimeouts.get(collection.name);
-      const t = timeouts?.get(key);
-      if (t)
-        clearTimeout(t);
-      if (current === 0) {
-        void this.fetchAndIngest(collection.name, selector).catch(this.onError);
-      }
-      void this.fulfillQuery(collection.name, selector, options).catch(this.onError);
-    };
-    const unregisterQuery = (selector, options) => {
-      const qid = queryId(selector, options);
-      const registry = this.queries.get(collection.name);
-      registry?.delete(qid);
-      const key = this.selectorKey(selector);
-      const perColObservers = this.activeObservers.get(collection.name);
-      const current = perColObservers?.get(key)?.count ?? 0;
-      const remaining = Math.max(0, current - 1);
-      if (remaining > 0) {
-        perColObservers?.set(key, { selector, count: remaining });
-        return;
-      }
-      const doPurge = () => {
-        perColObservers?.delete(key);
-        void this.purgeSelector(collection.name, selector).catch(this.onError);
-      };
-      if (this.purgeDelay === 0) {
-        doPurge();
-      } else {
-        const timeouts = this.observerTimeouts.get(collection.name);
-        const t = timeouts?.get(key);
-        if (t)
-          clearTimeout(t);
-        timeouts?.set(key, setTimeout(doPurge, this.purgeDelay));
-      }
-    };
-    const getQueryState = (selector, options) => {
-      const q = this.queries.get(collection.name)?.get(queryId(selector, options));
-      return q?.state ?? "active";
-    };
-    const getQueryError = (selector, options) => {
-      const q = this.queries.get(collection.name)?.get(queryId(selector, options));
-      return q?.error ?? null;
-    };
-    const getQueryResult = (selector, options) => {
-      const q = this.queries.get(collection.name)?.get(queryId(selector, options));
-      return q?.items ?? [];
-    };
-    const onQueryStateChange = (selector, options, callback) => {
-      const qid = queryId(selector, options);
-      const registry = this.queries.get(collection.name);
-      if (!registry)
-        throw new Error(`Collection ${collection.name} not initialized!`);
-      if (!registry.has(qid)) {
-        registry.set(qid, {
-          selector,
-          options,
-          state: "active",
-          error: null,
-          items: [],
-          listeners: /* @__PURE__ */ new Set()
-        });
-      }
-      registry.get(qid)?.listeners.add(callback);
-      return () => registry.get(qid)?.listeners.delete(callback);
-    };
-    return {
-      insert: async (item) => {
-        await ready;
-        const inserted = await this.insert(collection.name, item);
-        return inserted;
-      },
-      updateOne: async (selector, modifier) => {
-        await ready;
-        return this.updateOne(collection.name, selector, modifier);
-      },
-      updateMany: async (selector, modifier) => {
-        await ready;
-        return this.updateMany(collection.name, selector, modifier);
-      },
-      replaceOne: async (selector, replacement) => {
-        await ready;
-        return this.replaceOne(collection.name, selector, replacement);
-      },
-      removeOne: async (selector) => {
-        await ready;
-        return this.removeOne(collection.name, selector);
-      },
-      removeMany: async (selector) => {
-        await ready;
-        return this.removeMany(collection.name, selector);
-      },
-      registerQuery,
-      unregisterQuery,
-      getQueryState,
-      getQueryError,
-      getQueryResult,
-      onQueryStateChange,
-      dispose: async () => {
-        this.storageAdapters.delete(collection.name);
-        this.queries.delete(collection.name);
-        this.collectionIndices.delete(collection.name);
-        this.storageAdapterReady.delete(collection.name);
-        this.activeObservers.delete(collection.name);
-        this.observerTimeouts.delete(collection.name);
-        this.selectorIds.delete(collection.name);
-        this.idRefCounts.delete(collection.name);
-        this.autoloadIds.delete(collection.name);
-      },
-      isReady: async () => {
-        await ready;
-      }
-    };
-  }
-  // ===== Auto-fetch mechanics =====
-  selectorKey(selector) {
-    return JSON.stringify(selector ?? {});
-  }
-  async forceRefetchAll() {
-    const tasks = [];
-    for (const [collectionName, observers] of this.activeObservers.entries()) {
-      for (const { selector, count } of observers.values()) {
-        if (count > 0)
-          tasks.push(this.fetchAndIngest(collectionName, selector));
-      }
-    }
-    await Promise.all(tasks);
-  }
-  async fetchAndIngest(collectionName, selector) {
-    this.publishForSelector(collectionName, selector, "active", null);
-    try {
-      const items = await this.fetchQueryItems(collectionName, selector);
-      if (!items || !Array.isArray(items)) {
-        throw new Error("AutoFetchDataAdapter: fetchQueryItems must resolve to { items: T[] }");
-      }
-      const ids = items.map((i) => i.id);
-      const selectorKey = this.selectorKey(selector);
-      const selMap = this.selectorIds.get(collectionName);
-      const previous = selMap?.get(selectorKey) ?? /* @__PURE__ */ new Set();
-      ids.forEach((id) => previous.add(id));
-      selMap?.set(selectorKey, previous);
-      await this.upsertMerged(collectionName, items);
-      await this.checkQueryUpdates(collectionName, items);
-    } catch (error) {
-      this.publishForSelector(collectionName, selector, "error", error);
-      this.onError(error);
-    }
-  }
-  async purgeSelector(collectionName, selector) {
-    const selectorKey = this.selectorKey(selector);
-    const selMap = this.selectorIds.get(collectionName);
-    const ids = selMap?.get(selectorKey);
-    selMap?.delete(selectorKey);
-    if (!ids || ids.size === 0)
-      return;
-    const referenceMap = this.idRefCounts.get(collectionName);
-    const autoload = this.autoloadIds.get(collectionName);
-    const toRemove = [];
-    for (const id of ids) {
-      const current = referenceMap?.get(id) ?? 0;
-      const next = Math.max(0, current - 1);
-      if (next === 0) {
-        referenceMap?.delete(id);
-        if (autoload?.has(id))
-          toRemove.push(id);
-      } else {
-        referenceMap?.set(id, next);
-      }
-    }
-    if (toRemove.length === 0)
-      return;
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await storage.readIds(toRemove);
-    if (items.length > 0) {
-      await storage.remove(items);
-      await this.checkQueryUpdates(collectionName, items);
-    }
-    toRemove.forEach((id) => autoload?.delete(id));
-  }
-  // ===== Core query + CRUD plumbing (index-aware, same semantics as AsyncDataAdapter) =====
-  async setupStorage(collectionName, indices) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    await Promise.all([
-      storage.createIndex("id"),
-      ...indices.map((field) => storage.createIndex(field))
-    ]);
-    await storage.setup();
-  }
-  ensureStorageAdapter(name) {
-    if (this.storageAdapters.has(name))
-      return;
-    const adapter = this.options.storage && this.options.storage(name);
-    if (!adapter)
-      return;
-    this.storageAdapters.set(name, adapter);
-  }
-  publishForSelector(collectionName, selector, state, error) {
-    const registry = this.queries.get(collectionName);
-    if (!registry)
-      return;
-    for (const query of registry.values()) {
-      if (!isEqual(query.selector, selector))
-        continue;
-      query.state = state;
-      query.error = error;
-      for (const callback of query.listeners) {
-        try {
-          callback(state);
-        } catch (error_) {
-          this.onError(error_);
-        }
-      }
-    }
-  }
-  publishState(collectionName, qid, state, error) {
-    const rec = this.queries.get(collectionName)?.get(qid);
-    if (!rec)
-      return;
-    rec.state = state;
-    rec.error = error;
-    for (const callback of rec.listeners) {
-      try {
-        callback(state);
-      } catch (error_) {
-        this.onError(error_);
-      }
-    }
-  }
-  publishResult(collectionName, qid, items) {
-    const rec = this.queries.get(collectionName)?.get(qid);
-    if (!rec)
-      return;
-    rec.items = items;
-  }
-  async fulfillQuery(collectionName, selector, options) {
-    const qid = queryId(selector, options);
-    const registry = this.queries.get(collectionName);
-    if (!registry)
-      throw new Error(`Collection ${collectionName} not initialized!`);
-    const rec = registry.get(qid);
-    if (!rec)
-      return;
-    this.publishState(collectionName, qid, "active", null);
-    try {
-      const items = await this.executeQuery(collectionName, selector, options);
-      this.publishResult(collectionName, qid, items);
-      this.publishState(collectionName, qid, "complete", null);
-    } catch (error) {
-      this.publishState(collectionName, qid, "error", error);
-    }
-  }
-  async getIndexInfo(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") {
-      return { matched: true, ids: [selector.id], optimizedSelector: {} };
-    }
-    if (selector == null) {
-      return { matched: false, ids: [], optimizedSelector: {} };
-    }
-    const indices = this.collectionIndices.get(collectionName) ?? [];
-    return getIndexInfo(indices.map((field) => async (flatSelector) => {
-      if (!Object.hasOwnProperty.call(flatSelector, field))
-        return { matched: false };
-      const index = await storage.readIndex(field);
-      const fieldSelector = flatSelector[field];
-      const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
-      const keys = filtersForNull ? { include: null, exclude: [...index.keys()].filter((key) => key != null) } : getMatchingKeys(field, flatSelector);
-      if (keys.include == null && keys.exclude == null)
-        return { matched: false };
-      let includedIds = [];
-      if (keys.include == null) {
-        for (const set of index.values())
-          for (const pos of set)
-            includedIds.push(pos);
-      } else {
-        for (const key of keys.include) {
-          const idSet = index.get(key);
-          if (idSet)
-            for (const id of idSet)
-              includedIds.push(id);
-        }
-      }
-      if (keys.exclude != null) {
-        const excludeIds = /* @__PURE__ */ new Set();
-        for (const key of keys.exclude) {
-          const idSet = index.get(key);
-          if (idSet)
-            for (const id of idSet)
-              excludeIds.add(id);
-        }
-        includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
-      }
-      return {
-        matched: true,
-        ids: includedIds,
-        fields: [field],
-        keepSelector: filtersForNull
-      };
-    }), selector);
-  }
-  async queryItems(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const index = await this.getIndexInfo(collectionName, selector);
-    const matchItems = (item) => {
-      if (index.optimizedSelector == null)
-        return true;
-      if (Object.keys(index.optimizedSelector).length <= 0)
-        return true;
-      return match(item, index.optimizedSelector);
-    };
-    if (index.matched) {
-      const items = await storage.readIds(index.ids);
-      if (isEqual(index.optimizedSelector, {}))
-        return items;
-      return items.filter(matchItems);
-    } else {
-      const allItems = await storage.readAll();
-      if (isEqual(selector, {}))
-        return allItems;
-      return allItems.filter(matchItems);
-    }
-  }
-  async executeQuery(collectionName, selector, options) {
-    const items = await this.queryItems(collectionName, selector || {});
-    const { sort, skip, limit, fields } = options || {};
-    const sorted = sort ? sortItems(items, sort) : items;
-    const skipped = skip ? sorted.slice(skip) : sorted;
-    const limited = limit ? skipped.slice(0, limit) : skipped;
-    const idExcluded = fields && fields.id === 0;
-    return limited.map((item) => {
-      if (!fields)
-        return item;
-      return { ...idExcluded ? {} : { id: item.id }, ...project(item, fields) };
-    });
-  }
-  async checkQueryUpdates(collectionName, changedItems) {
-    const registry = this.queries.get(collectionName);
-    if (!registry)
-      throw new Error(`Collection ${collectionName} not initialized!`);
-    if (registry.size === 0)
-      return;
-    const affected = [...registry.values()].filter(({ selector }) => changedItems.some((item) => match(item, selector)));
-    if (affected.length === 0)
-      return;
-    for (const { selector, options } of affected) {
-      const qid = queryId(selector, options);
-      this.publishState(collectionName, qid, "active", null);
-    }
-    await Promise.all(affected.map(async ({ selector, options }) => {
-      const qid = queryId(selector, options);
-      try {
-        const items = await this.executeQuery(collectionName, selector, options);
-        this.publishResult(collectionName, qid, items);
-        this.publishState(collectionName, qid, "complete", null);
-      } catch (error) {
-        this.publishState(collectionName, qid, "error", error);
-      }
-    }));
-  }
-  // ===== CRUD with push-style query updates =====
-  async insert(collectionName, newItem) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const existing = await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 });
-    if (existing.length > 0)
-      throw new Error(`Item with id ${String(newItem.id)} already exists`);
-    await storage.insert([newItem]);
-    await this.checkQueryUpdates(collectionName, [newItem]);
-    return newItem;
-  }
-  async updateOne(collectionName, selector, modifier) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector, { limit: 1 });
-    const [item] = items;
-    const { $setOnInsert, ...rest } = modifier;
-    if (item == null)
-      return [];
-    const modified = modify(deepClone(item), rest);
-    if (item.id !== modified.id) {
-      const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
-      if (existing.length > 0)
-        throw new Error(`Item with id ${String(modified.id)} already exists`);
-    }
-    await storage.replace([modified]);
-    await this.checkQueryUpdates(collectionName, [modified]);
-    return [modified];
-  }
-  async updateMany(collectionName, selector, modifier) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector);
-    if (items.length === 0)
-      return [];
-    const { $setOnInsert, ...rest } = modifier;
-    const changed = await Promise.all(items.map(async (item) => {
-      const modified = modify(deepClone(item), rest);
-      if (item.id !== modified.id) {
-        const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
-        if (existing.length > 0)
-          throw new Error(`Item with id ${String(modified.id)} already exists`);
-      }
-      return modified;
-    }));
-    await storage.replace(changed);
-    await this.checkQueryUpdates(collectionName, changed);
-    return changed;
-  }
-  async replaceOne(collectionName, selector, replacement) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector, { limit: 1 });
-    const [item] = items;
-    if (item == null)
-      return [];
-    const modified = { ...replacement, id: replacement.id ?? item.id };
-    if (item.id !== modified.id) {
-      const existing = await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 });
-      if (existing.length > 0)
-        throw new Error(`Item with id ${String(modified.id)} already exists`);
-    }
-    await storage.replace([modified]);
-    await this.checkQueryUpdates(collectionName, [modified]);
-    return [modified];
-  }
-  async removeOne(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector, { limit: 1 });
-    const [item] = items;
-    if (item == null)
-      return [];
-    await storage.remove([item]);
-    await this.checkQueryUpdates(collectionName, [item]);
-    return [item];
-  }
-  async removeMany(collectionName, selector) {
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const items = await this.executeQuery(collectionName, selector);
-    if (items.length === 0)
-      return [];
-    await storage.remove(items);
-    await this.checkQueryUpdates(collectionName, items);
-    return items;
-  }
-  // ===== Upsert/merge helper for ingesting fetched items =====
-  async upsertMerged(collectionName, incoming) {
-    if (incoming.length === 0)
-      return;
-    const storage = this.storageAdapters.get(collectionName);
-    if (!storage)
-      throw new Error(`No persistence adapter for collection ${collectionName}`);
-    const ids = incoming.map((i) => i.id);
-    const existing = await storage.readIds(ids);
-    const existingById = new Map(existing.map((it) => [it.id, it]));
-    const toInsert = [];
-    const toReplace = [];
-    const referenceMap = this.idRefCounts.get(collectionName);
-    const autoload = this.autoloadIds.get(collectionName);
-    for (const item of incoming) {
-      const previous = existingById.get(item.id);
-      if (previous) {
-        toReplace.push(this.mergeItems(previous, item));
-      } else {
-        toInsert.push(item);
-      }
-      autoload?.add(item.id);
-      referenceMap?.set(item.id, (referenceMap?.get(item.id) ?? 0) + 1);
-    }
-    if (toInsert.length > 0)
-      await storage.insert(toInsert);
-    if (toReplace.length > 0)
-      await storage.replace(toReplace);
-  }
+/**
+* Optimizes a logic gate ($and/$or) of selectors by querying multiple index providers.
+* @param queryFunctions - An array of index providers to query.
+* @param logicGate - An array of selectors representing the logic gate.
+* @param idsCallback - A callback function called with matched ids.
+* @returns An array of optimized selectors or a promise that resolves to such an array.
+*/
+function optimizeLogicGate(queryFunctions, logicGate, idsCallback) {
+	return logicGate.reduce((memoOrPromise, sel) => {
+		const getSelector = (indexInfo) => {
+			const { matched: selMatched, ids: selIds, optimizedSelector } = indexInfo;
+			if (selMatched) {
+				idsCallback(true, selIds);
+				if (Object.keys(optimizedSelector).length > 0) return optimizedSelector;
+			} else {
+				idsCallback(false, []);
+				return sel;
+			}
+		};
+		const indexInfoOrPromise = getIndexInfo(queryFunctions, sel);
+		if (indexInfoOrPromise instanceof Promise) return indexInfoOrPromise.then(async (indexInfo) => {
+			const memo = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+			const optimizedSelector = getSelector(indexInfo);
+			if (optimizedSelector) memo.push(optimizedSelector);
+			return memo;
+		});
+		const memo = memoOrPromise;
+		if (memo instanceof Promise) throw new Error("Mixing async and sync index providers is not supported");
+		const optimizedSelector = getSelector(indexInfoOrPromise);
+		if (optimizedSelector) memo.push(optimizedSelector);
+		return memo;
+	}, []);
 }
-export {
-  AutoFetchDataAdapter as default
-};
+/**
+* Retrieves index information for a given complex selector by querying multiple
+* index providers. Handles nested `$and` and `$or` conditions in the selector and
+* optimizes the selector to minimize processing overhead.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param queryFunctions - An array of index providers to query.
+* @param selector - The complex selector used to filter items.
+* @returns An object containing:
+*   - `matched`: A boolean indicating if the selector matched any items.
+*   - `ids`: An array of matched item ids.
+*   - `optimizedSelector`: A selector optimized based on the index results, with unused
+*     conditions removed.
+*/
+function getIndexInfo(queryFunctions, selector) {
+	if (selector == null || Object.keys(selector).length <= 0) return {
+		matched: false,
+		ids: [],
+		optimizedSelector: selector
+	};
+	const { $and, $or, ...rest } = selector;
+	const flatInfoOrPromise = getMergedIndexInfo(queryFunctions, rest);
+	const processFlatInfo = (flatInfo) => {
+		let { matched, ids } = flatInfo;
+		const newSelector = flatInfo.optimizedSelector;
+		const $andNewOrPromise = Array.isArray($and) ? optimizeLogicGate(queryFunctions, $and, (match, selIds) => {
+			if (!match) return;
+			ids = matched ? intersection(ids, selIds) : selIds;
+			matched = true;
+		}) : void 0;
+		const process$and = ($andNew) => {
+			if ($andNew && $andNew.length > 0) newSelector.$and = $andNew;
+			let hasNonIndexField = false;
+			const matchedBefore = matched;
+			const idsBefore = ids;
+			const process$or = ($orNew) => {
+				if (hasNonIndexField || $orNew && $orNew.length > 0) {
+					newSelector.$or = $or;
+					matched = matchedBefore;
+					ids = idsBefore;
+				}
+				return {
+					matched,
+					ids: ids || [],
+					optimizedSelector: newSelector
+				};
+			};
+			const $orNewOrPromise = Array.isArray($or) ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
+				if (match) {
+					ids = [...new Set([...ids, ...selIds])];
+					matched = true;
+				} else hasNonIndexField = true;
+			}) : void 0;
+			if ($orNewOrPromise instanceof Promise) return $orNewOrPromise.then(($orNew) => process$or($orNew));
+			return process$or($orNewOrPromise);
+		};
+		if ($andNewOrPromise instanceof Promise) return $andNewOrPromise.then(($andNew) => process$and($andNew));
+		return process$and($andNewOrPromise);
+	};
+	if (flatInfoOrPromise instanceof Promise) return flatInfoOrPromise.then(processFlatInfo);
+	return processFlatInfo(flatInfoOrPromise);
+}
+//#endregion
+export { getIndexInfo as default };