@signaldb/core 2.0.0-beta.4 → 2.0.0-beta.5

package/dist/index.cjs23.js

@@ -1,7 +1,129 @@
 "use strict";
-const mingo = require("mingo");
-function match(item, selector) {
-  const query = new mingo.Query(selector);
-  return query.test(item);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const intersection = require("./index.cjs30.js");
+function getMergedIndexInfo(queryFunctions, selector) {
+  return queryFunctions.reduce((memoOrPromise, queryFunction) => {
+    const resultOrPromise = queryFunction(selector);
+    const processResult = (memo2, result) => {
+      if (!result.matched)
+        return memo2;
+      const optimizedSelector = result.keepSelector ? memo2.optimizedSelector : Object.fromEntries(Object.entries(memo2.optimizedSelector).filter(([key]) => !result.fields.includes(key)));
+      return {
+        matched: true,
+        ids: [...new Set(memo2.matched ? intersection(memo2.ids, result.ids) : result.ids)],
+        optimizedSelector
+      };
+    };
+    if (resultOrPromise instanceof Promise) {
+      return resultOrPromise.then(async (result) => {
+        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+        return processResult(memo2, 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 }
+  });
 }
-module.exports = match;
+function optimizeLogicGate(queryFunctions, logicGate, idsCallback) {
+  return logicGate.reduce((memoOrPromise, sel) => {
+    const getSelector = (indexInfo) => {
+      const { matched: selMatched, ids: selIds, optimizedSelector: optimizedSelector2 } = indexInfo;
+      if (selMatched) {
+        idsCallback(true, selIds);
+        if (Object.keys(optimizedSelector2).length > 0) {
+          return optimizedSelector2;
+        }
+      } else {
+        idsCallback(false, []);
+        return sel;
+      }
+    };
+    const indexInfoOrPromise = getIndexInfo(queryFunctions, sel);
+    if (indexInfoOrPromise instanceof Promise) {
+      return indexInfoOrPromise.then(async (indexInfo) => {
+        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+        const optimizedSelector2 = getSelector(indexInfo);
+        if (optimizedSelector2)
+          memo2.push(optimizedSelector2);
+        return memo2;
+      });
+    }
+    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;
+  }, []);
+}
+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 ($orNew && $orNew.length > 0)
+          newSelector.$or = $orNew;
+        if (hasNonIndexField) {
+          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 = [.../* @__PURE__ */ 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);
+}
+exports.default = getIndexInfo;
+exports.getMergedIndexInfo = getMergedIndexInfo;

package/dist/index.cjs24.js

@@ -1,27 +1,7 @@
 "use strict";
-const get = require("./index.cjs10.js");
-const set = require("./index.cjs32.js");
-function project(item, fields) {
-  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
-  if (allFieldsDeactivated) {
-    const result2 = { ...item };
-    Object.keys(fields).forEach((key) => {
-      const fieldValue = get(item, key);
-      if (fieldValue === void 0)
-        return;
-      set(result2, key, void 0, true);
-    });
-    return result2;
-  }
-  const result = {};
-  Object.entries(fields).forEach(([key, value]) => {
-    const fieldValue = get(item, key);
-    if (fieldValue === void 0)
-      return;
-    if (fieldValue == null && value !== 1)
-      return;
-    set(result, key, value === 1 ? fieldValue : void 0);
-  });
-  return result;
+const mingo = require("mingo");
+function match(item, selector) {
+  const query = new mingo.Query(selector);
+  return query.test(item);
 }
-module.exports = project;
+module.exports = match;

package/dist/index.cjs25.js

@@ -1,10 +1,27 @@
 "use strict";
-const fastSort = require("fast-sort");
 const get = require("./index.cjs10.js");
-function sortItems(items, sortFields) {
-  return fastSort.sort(items).by(Object.entries(sortFields).map(([key, value]) => {
-    const order = value === 1 ? "asc" : "desc";
-    return { [order]: (i) => get(i, key) };
-  }));
+const set = require("./index.cjs32.js");
+function project(item, fields) {
+  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
+  if (allFieldsDeactivated) {
+    const result2 = { ...item };
+    Object.keys(fields).forEach((key) => {
+      const fieldValue = get(item, key);
+      if (fieldValue === void 0)
+        return;
+      set(result2, key, void 0, true);
+    });
+    return result2;
+  }
+  const result = {};
+  Object.entries(fields).forEach(([key, value]) => {
+    const fieldValue = get(item, key);
+    if (fieldValue === void 0)
+      return;
+    if (fieldValue == null && value !== 1)
+      return;
+    set(result, key, value === 1 ? fieldValue : void 0);
+  });
+  return result;
 }
-module.exports = sortItems;
+module.exports = project;

package/dist/index.cjs26.js

@@ -1,29 +1,10 @@
 "use strict";
-const isFieldExpression = require("./index.cjs33.js");
-const serializeValue = require("./index.cjs11.js");
-function getMatchingKeys(field, selector) {
-  const result = { include: null, exclude: null };
-  const fieldSelector = selector[field];
-  if (fieldSelector instanceof RegExp)
-    return result;
-  if (fieldSelector == null)
-    return result;
-  if (isFieldExpression(fieldSelector)) {
-    if (fieldSelector.$ne != null) {
-      result.exclude = [serializeValue(fieldSelector.$ne)];
-      return result;
-    }
-    if (Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0) {
-      result.include = fieldSelector.$in.map(serializeValue);
-      return result;
-    }
-    if (Array.isArray(fieldSelector.$nin) && fieldSelector.$nin.length > 0) {
-      result.exclude = fieldSelector.$nin.map(serializeValue);
-      return result;
-    }
-    return { include: null, exclude: null };
-  }
-  result.include = [serializeValue(fieldSelector)];
-  return result;
+const fastSort = require("fast-sort");
+const get = require("./index.cjs10.js");
+function sortItems(items, sortFields) {
+  return fastSort.sort(items).by(Object.entries(sortFields).map(([key, value]) => {
+    const order = value === 1 ? "asc" : "desc";
+    return { [order]: (i) => get(i, key) };
+  }));
 }
-module.exports = getMatchingKeys;
+module.exports = sortItems;

package/dist/index.cjs27.js

@@ -1,46 +1,29 @@
 "use strict";
-function batchOnNextTick(onFlush) {
-  const queues = /* @__PURE__ */ new Map();
-  function enqueue(key, args) {
-    return new Promise((resolve, reject) => {
-      let q = queues.get(key);
-      if (!q) {
-        q = {
-          timer: null,
-          items: [],
-          flush: () => flush(key)
-        };
-        queues.set(key, q);
-      }
-      q.items.push({ args, resolve, reject });
-      if (q.timer == null) {
-        q.timer = setTimeout(() => {
-          q.timer = null;
-          void q.flush();
-        }, 0);
-      }
-    });
-  }
-  async function flush(key) {
-    const q = queues.get(key);
-    if (!q || q.items.length === 0)
-      return;
-    if (q.timer != null) {
-      clearTimeout(q.timer);
-      q.timer = null;
+const isFieldExpression = require("./index.cjs31.js");
+const serializeValue = require("./index.cjs11.js");
+function getMatchingKeys(field, selector) {
+  const result = { include: null, exclude: null };
+  const fieldSelector = selector[field];
+  if (fieldSelector instanceof RegExp)
+    return result;
+  if (fieldSelector == null)
+    return result;
+  if (isFieldExpression(fieldSelector)) {
+    if (fieldSelector.$ne != null) {
+      result.exclude = [serializeValue(fieldSelector.$ne)];
+      return result;
+    }
+    if (Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0) {
+      result.include = fieldSelector.$in.map(serializeValue);
+      return result;
+    }
+    if (Array.isArray(fieldSelector.$nin) && fieldSelector.$nin.length > 0) {
+      result.exclude = fieldSelector.$nin.map(serializeValue);
+      return result;
     }
-    const items = q.items.splice(0);
-    onFlush(key, items.map((i) => i.args)).then((results) => {
-      for (const [index, result] of results.entries()) {
-        const { resolve } = items[index];
-        resolve(result);
-      }
-    }).catch((error) => {
-      for (const { reject } of items) {
-        reject(error);
-      }
-    });
+    return { include: null, exclude: null };
   }
-  return { enqueue, flush };
+  result.include = [serializeValue(fieldSelector)];
+  return result;
 }
-module.exports = batchOnNextTick;
+module.exports = getMatchingKeys;

package/dist/index.cjs28.js

@@ -1,8 +1,46 @@
 "use strict";
-function truthy(value) {
-  return !!value;
+function batchOnNextTick(onFlush) {
+  const queues = /* @__PURE__ */ new Map();
+  function enqueue(key, args) {
+    return new Promise((resolve, reject) => {
+      let q = queues.get(key);
+      if (!q) {
+        q = {
+          timer: null,
+          items: [],
+          flush: () => flush(key)
+        };
+        queues.set(key, q);
+      }
+      q.items.push({ args, resolve, reject });
+      if (q.timer == null) {
+        q.timer = setTimeout(() => {
+          q.timer = null;
+          void q.flush();
+        }, 0);
+      }
+    });
+  }
+  async function flush(key) {
+    const q = queues.get(key);
+    if (!q || q.items.length === 0)
+      return;
+    if (q.timer != null) {
+      clearTimeout(q.timer);
+      q.timer = null;
+    }
+    const items = q.items.splice(0);
+    onFlush(key, items.map((i) => i.args)).then((results) => {
+      for (const [index, result] of results.entries()) {
+        const { resolve } = items[index];
+        resolve(result);
+      }
+    }).catch((error) => {
+      for (const { reject } of items) {
+        reject(error);
+      }
+    });
+  }
+  return { enqueue, flush };
 }
-function compact(array) {
-  return array.filter(truthy);
-}
-module.exports = compact;
+module.exports = batchOnNextTick;

package/dist/index.cjs29.js

@@ -1,9 +1,8 @@
 "use strict";
-function uniqueBy(array, fn) {
-  const set = /* @__PURE__ */ new Set();
-  return array.filter((element) => {
-    const value = typeof fn === "function" ? fn(element) : element[fn];
-    return !set.has(value) && set.add(value);
-  });
+function truthy(value) {
+  return !!value;
 }
-module.exports = uniqueBy;
+function compact(array) {
+  return array.filter(truthy);
+}
+module.exports = compact;

package/dist/index.cjs3.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const EventEmitter = require("./index.cjs9.js");
-const createSignal = require("./index.cjs18.js");
+const createSignal = require("./index.cjs19.js");
 const randomId = require("./index.cjs8.js");
-const DefaultDataAdapter = require("./index.cjs12.js");
+const DefaultDataAdapter = require("./index.cjs13.js");
 const modify = require("./index.cjs7.js");
-const deepClone = require("./index.cjs19.js");
-const queryId = require("./index.cjs20.js");
+const deepClone = require("./index.cjs20.js");
+const queryId = require("./index.cjs21.js");
 const Cursor = require("./index.cjs2.js");
 class Collection extends EventEmitter {
   static collections = [];
@@ -246,14 +246,6 @@ class Collection extends EventEmitter {
     Collection.collections = Collection.collections.filter((collection) => collection !== this);
     Collection.onDisposeCallbacks.forEach((callback) => callback(this));
   }
-  /**
-   * 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");
@@ -283,7 +275,8 @@ class Collection extends EventEmitter {
           requery();
         };
         const listeners = this.queryListeners({ selector, options });
-        if (listeners === 0)
+        const didRegister = listeners === 0;
+        if (didRegister)
           this.backend.registerQuery(selector, options || {});
         this.queryListeners({ selector, options }, listeners + 1);
         const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options || {}, (state) => {
@@ -293,14 +286,14 @@ class Collection extends EventEmitter {
         });
         this.emit("observer.created", selector, options);
         return () => {
-          setTimeout(() => {
+          queueMicrotask(() => {
             const newListeners = Math.max(0, this.queryListeners({ selector, options }) - 1);
-            if (newListeners === 0)
+            if (newListeners === 0 && didRegister)
               this.backend.unregisterQuery(selector, options || {});
             this.queryListeners({ selector, options }, newListeners);
             queryStateChangeCleanup();
             this.emit("observer.disposed", selector, options);
-          }, 0);
+          });
         };
       }
     });
@@ -308,16 +301,6 @@ class Collection extends EventEmitter {
     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 Async - Whether to perform the operation asynchronously.
-   * @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");

package/dist/index.cjs30.js

@@ -1,5 +1,7 @@
 "use strict";
-function createIndexProvider(definition) {
-  return definition;
+function intersection(...arrays) {
+  if (arrays.length === 0)
+    return [];
+  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
 }
-module.exports = createIndexProvider;
+module.exports = intersection;

package/dist/index.cjs31.js

@@ -1,7 +1,42 @@
 "use strict";
-function intersection(...arrays) {
-  if (arrays.length === 0)
-    return [];
-  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+const expressionKeys = /* @__PURE__ */ new Set([
+  "$eq",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$in",
+  "$nin",
+  "$ne",
+  "$exists",
+  "$not",
+  "$expr",
+  "$jsonSchema",
+  "$mod",
+  "$regex",
+  "$options",
+  "$text",
+  "$where",
+  "$all",
+  "$elemMatch",
+  "$size",
+  "$bitsAllClear",
+  "$bitsAllSet",
+  "$bitsAnyClear",
+  "$bitsAnySet"
+]);
+function isFieldExpression(expression) {
+  if (typeof expression !== "object" || expression == null) {
+    return false;
+  }
+  const keys = Object.keys(expression);
+  if (keys.length === 0) {
+    return false;
+  }
+  const hasInvalidKeys = keys.some((key) => !expressionKeys.has(key));
+  if (hasInvalidKeys)
+    return false;
+  const hasValidKeys = keys.every((key) => expressionKeys.has(key));
+  return hasValidKeys;
 }
-module.exports = intersection;
+module.exports = isFieldExpression;

package/dist/index.cjs33.js

@@ -1,42 +1,5 @@
 "use strict";
-const expressionKeys = /* @__PURE__ */ new Set([
-  "$eq",
-  "$gt",
-  "$gte",
-  "$lt",
-  "$lte",
-  "$in",
-  "$nin",
-  "$ne",
-  "$exists",
-  "$not",
-  "$expr",
-  "$jsonSchema",
-  "$mod",
-  "$regex",
-  "$options",
-  "$text",
-  "$where",
-  "$all",
-  "$elemMatch",
-  "$size",
-  "$bitsAllClear",
-  "$bitsAllSet",
-  "$bitsAnyClear",
-  "$bitsAnySet"
-]);
-function isFieldExpression(expression) {
-  if (typeof expression !== "object" || expression == null) {
-    return false;
-  }
-  const keys = Object.keys(expression);
-  if (keys.length === 0) {
-    return false;
-  }
-  const hasInvalidKeys = keys.some((key) => !expressionKeys.has(key));
-  if (hasInvalidKeys)
-    return false;
-  const hasValidKeys = keys.every((key) => expressionKeys.has(key));
-  return hasValidKeys;
+function createIndexProvider(definition) {
+  return definition;
 }
-module.exports = isFieldExpression;
+module.exports = createIndexProvider;

package/dist/index.cjs34.js

@@ -0,0 +1,9 @@
+"use strict";
+function uniqueBy(array, fn) {
+  const set = /* @__PURE__ */ new Set();
+  return array.filter((element) => {
+    const value = typeof fn === "function" ? fn(element) : element[fn];
+    return !set.has(value) && set.add(value);
+  });
+}
+module.exports = uniqueBy;

package/dist/index.cjs7.js

@@ -1,6 +1,6 @@
 "use strict";
 const mingo = require("mingo");
-const deepClone = require("./index.cjs19.js");
+const deepClone = require("./index.cjs20.js");
 function modify(item, modifier) {
   const hasOperators = Object.keys(modifier).some((key) => key.startsWith("$"));
   if (!hasOperators)

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export type { default as ReactivityAdapter } from './types/ReactivityAdapter';
 export type { default as StorageAdapter, Changeset, } from './types/StorageAdapter';
 export type { default as Selector } from './types/Selector';
 export type { default as Modifier } from './types/Modifier';
-export type { BaseItem, ObserveCallbacks, CursorOptions, Transform, TransformAll, SortSpecifier, FieldSpecifier, FindOptions, CollectionOptions, } from './Collection';
+export type { BaseItem, ObserveCallbacks, CursorOptions, Transform, TransformAll, SortSpecifier, FieldSpecifier, AnyFindOptions, AsyncFindOptions, FindOptions, SyncFindOptions, CollectionOptions, } from './Collection';
 export type { default as DataAdapter } from './DataAdapter';
 export { default as Cursor } from './Collection/Cursor';
 export { default as Collection } from './Collection';
@@ -14,6 +14,7 @@ export { default as randomId } from './utils/randomId';
 export { default as EventEmitter } from './utils/EventEmitter';
 export { default as get } from './utils/get';
 export { default as serializeValue } from './utils/serializeValue';
+export { default as reactiveOrAsync, unwrap } from './utils/reactiveOrAsync';
 export { default as DefaultDataAdapter } from './DefaultDataAdapter';
 export { default as AsyncDataAdapter } from './AsyncDataAdapter';
 export { default as WorkerDataAdapter } from './WorkerDataAdapter';

package/dist/index.mjs

@@ -8,25 +8,28 @@ import { default as default8 } from "./index8.mjs";
 import { default as default9 } from "./index9.mjs";
 import { default as default10 } from "./index10.mjs";
 import { default as default11 } from "./index11.mjs";
-import { default as default12 } from "./index12.mjs";
+import { default as default12, unwrap } from "./index12.mjs";
 import { default as default13 } from "./index13.mjs";
 import { default as default14 } from "./index14.mjs";
 import { default as default15 } from "./index15.mjs";
 import { default as default16 } from "./index16.mjs";
+import { default as default17 } from "./index17.mjs";
 export {
-  default13 as AsyncDataAdapter,
-  default16 as AutoFetchDataAdapter,
+  default14 as AsyncDataAdapter,
+  default17 as AutoFetchDataAdapter,
   default3 as Collection,
   default2 as Cursor,
-  default12 as DefaultDataAdapter,
+  default13 as DefaultDataAdapter,
   default9 as EventEmitter,
-  default14 as WorkerDataAdapter,
-  default15 as WorkerDataAdapterHost,
+  default15 as WorkerDataAdapter,
+  default16 as WorkerDataAdapterHost,
   default5 as createReactivityAdapter,
   default4 as createStorageAdapter,
   default10 as get,
   default6 as isEqual,
   default7 as modify,
   default8 as randomId,
-  default11 as serializeValue
+  default12 as reactiveOrAsync,
+  default11 as serializeValue,
+  unwrap
 };