@signaldb/core 1.7.1 → 2.0.0-beta.1

package/dist/index2.mjs

@@ -1,5 +1,3 @@
-import sortItems from "./index15.mjs";
-import project from "./index16.mjs";
 import Observer from "./index17.mjs";
 function isInReactiveScope(reactivity) {
   if (!reactivity)
@@ -10,7 +8,7 @@ function isInReactiveScope(reactivity) {
 }
 class Cursor {
   observer;
-  getFilteredItems;
+  getItems;
   options;
   onCleanupCallbacks = [];
   /**
@@ -30,7 +28,7 @@ class Cursor {
    * @param options.fieldTracking - A boolean to enable fine-grained field tracking for reactivity.
    */
   constructor(getItems, options) {
-    this.getFilteredItems = getItems;
+    this.getItems = getItems;
     this.options = options || {};
   }
   addGetters(item) {
@@ -61,26 +59,13 @@ class Cursor {
       return item;
     return this.options.transform(item);
   }
-  getItems() {
-    const items = this.getFilteredItems();
-    const { sort, skip, limit } = this.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 = this.options.fields && this.options.fields.id === 0;
-    return limited.map((item) => {
-      if (!this.options.fields)
-        return item;
-      return {
-        ...idExcluded ? {} : { id: item.id },
-        ...project(item, this.options.fields)
-      };
-    });
-  }
   depend(changeEvents) {
-    if (!this.options.reactive)
+    if (this.options?.async)
       return;
-    if (!isInReactiveScope(this.options.reactive))
+    if (!isInReactiveScope(this.options.reactive)) {
+      console.warn("Cursor.depend() called outside of a reactive scope without async option; consider using { async: true } or wrapping in a reactive scope");
+    }
+    if (!this.options.reactive)
       return;
     const signal = this.options.reactive.create();
     signal.depend();
@@ -114,7 +99,7 @@ class Cursor {
     if (!this.observer) {
       const observer = new Observer(() => {
         const requery = () => {
-          observer.runChecks(this.getItems());
+          observer.runChecks(this.getItems);
         };
         const cleanup = this.options.bindEvents && this.options.bindEvents(requery);
         return () => {
@@ -130,7 +115,7 @@ class Cursor {
   observeRawChanges(callbacks, skipInitial = false) {
     const observer = this.ensureObserver();
     observer.addCallbacks(callbacks, skipInitial);
-    observer.runChecks(this.getItems());
+    observer.runChecks(this.getItems);
     return () => {
       observer.removeCallbacks(callbacks);
       if (!observer.isEmpty())
@@ -164,18 +149,27 @@ class Cursor {
    * ⚡️ this function is reactive!
    * @param callback - A function to execute for each item in the result set.
    * @param callback.item - The transformed item.
+   * @returns A promise that resolves when all items have been processed, or void if not in async mode.
    */
   forEach(callback) {
-    const items = this.getItems();
     this.depend({
       addedBefore: true,
       removed: true,
       movedBefore: true,
       ...this.options.fieldTracking ? {} : { changed: true }
     });
-    items.forEach((item) => {
-      callback(this.transform(item));
-    });
+    const executeForEach = (items) => {
+      items.forEach((item) => {
+        callback(this.transform(item));
+      });
+    };
+    const result = this.getItems();
+    if (result instanceof Promise) {
+      return result.then(executeForEach);
+    } else {
+      executeForEach(result);
+      return void 0;
+    }
   }
   /**
    * Creates a new array populated with the results of applying the provided callback
@@ -188,9 +182,12 @@ class Cursor {
    */
   map(callback) {
     const results = [];
-    this.forEach((item) => {
+    const maybePromise = this.forEach((item) => {
       results.push(callback(item));
     });
+    if (maybePromise instanceof Promise) {
+      return maybePromise.then(() => results);
+    }
     return results;
   }
   /**
@@ -209,12 +206,12 @@ class Cursor {
    * @returns The total number of items in the result set.
    */
   count() {
-    const items = this.getItems();
     this.depend({
       added: true,
       removed: true
     });
-    return items.length;
+    const maybePromise = this.getItems();
+    return maybePromise instanceof Promise ? maybePromise.then((items) => items.length) : maybePromise.length;
   }
   /**
    * Observes changes to the cursor's result set and triggers the specified callbacks
@@ -252,7 +249,7 @@ class Cursor {
   requery() {
     if (!this.observer)
       return;
-    this.observer.runChecks(this.getItems());
+    this.observer.runChecks(this.getItems);
   }
 }
 export {

package/dist/index20.mjs

@@ -1,16 +1,8 @@
-function serializeValue(value) {
-  if (value == null)
-    return null;
-  if (typeof value === "string")
-    return value;
-  if (typeof value === "number")
-    return value.toString();
-  if (typeof value === "boolean")
-    return value.toString();
-  if (value instanceof Date)
-    return value.toISOString();
-  return JSON.stringify(value);
+function queryId(selector, options) {
+  const selectorId = JSON.stringify(selector);
+  const optionsId = options == null ? -1 : JSON.stringify(options);
+  return `${selectorId}:${optionsId}`;
 }
 export {
-  serializeValue as default
+  queryId as default
 };

package/dist/index21.mjs

@@ -1,27 +1,105 @@
-function createSignal(reactivityAdapter, initialValue, isEqual = Object.is) {
-  let value = initialValue;
-  const dependency = reactivityAdapter?.create();
-  const isInReactiveScope = () => {
-    if (!reactivityAdapter?.isInScope)
-      return true;
-    return reactivityAdapter.isInScope();
+import createIndexProvider from "./index30.mjs";
+import get from "./index10.mjs";
+import getMatchingKeys from "./index26.mjs";
+import serializeValue from "./index11.mjs";
+function createIndex(field) {
+  const index = /* @__PURE__ */ new Map();
+  const ensureSet = (key) => {
+    let set = index.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      index.set(key, set);
+    }
+    return set;
   };
-  const signal = {
-    get() {
-      if (dependency && isInReactiveScope())
-        dependency.depend();
-      return value;
+  return createIndexProvider({
+    query(selector) {
+      if (!Object.hasOwnProperty.call(selector, field)) {
+        return { matched: false };
+      }
+      const fieldSelector = selector[field];
+      const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
+      const keys = filteresForNull ? { include: null, exclude: [...index.keys()].filter((key) => key != null) } : getMatchingKeys(field, selector);
+      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 posSet = index.get(key);
+          if (posSet) {
+            for (const pos of posSet) {
+              includedIds.push(pos);
+            }
+          }
+        }
+      }
+      if (keys.exclude != null) {
+        const excludeIds = /* @__PURE__ */ new Set();
+        for (const key of keys.exclude) {
+          const posSet = index.get(key);
+          if (posSet) {
+            for (const pos of posSet) {
+              excludeIds.add(pos);
+            }
+          }
+        }
+        includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
+      }
+      return {
+        matched: true,
+        ids: includedIds,
+        fields: [field],
+        keepSelector: filteresForNull
+      };
+    },
+    rebuild(items) {
+      index.clear();
+      items.forEach((item) => {
+        const value = serializeValue(get(item, field));
+        ensureSet(value).add(item.id);
+      });
+    },
+    // NEW: delta methods
+    insert(items) {
+      for (const item of items) {
+        const value = serializeValue(get(item, field));
+        ensureSet(value).add(item.id);
+      }
     },
-    set(newValue) {
-      if (isEqual(value, newValue))
-        return;
-      value = newValue;
-      if (dependency)
-        dependency.notify();
+    remove(items) {
+      for (const item of items) {
+        const value = serializeValue(get(item, field));
+        const set = index.get(value);
+        if (!set)
+          continue;
+        set.delete(item.id);
+        if (set.size === 0)
+          index.delete(value);
+      }
+    },
+    update(pairs) {
+      for (const { oldItem, newItem } of pairs) {
+        const oldValue = serializeValue(get(oldItem, field));
+        const newValue = serializeValue(get(newItem, field));
+        if (oldValue === newValue)
+          continue;
+        const oldSet = index.get(oldValue);
+        if (oldSet) {
+          oldSet.delete(oldItem.id);
+          if (oldSet.size === 0)
+            index.delete(oldValue);
+        }
+        ensureSet(newValue).add(newItem.id);
+      }
     }
-  };
-  return signal;
+  });
 }
 export {
-  createSignal as default
+  createIndex as default
 };

package/dist/index22.mjs

@@ -1,77 +1,127 @@
-import intersection from "./index27.mjs";
-function getMergedIndexInfo(indexProviders, selector) {
-  return indexProviders.reduce((memo, indexProvider) => {
-    const info = indexProvider.query(selector);
-    if (!info.matched)
-      return memo;
-    const optimizedSelector = info.keepSelector ? memo.optimizedSelector : Object.fromEntries(Object.entries(memo.optimizedSelector).filter(([key]) => !info.fields.includes(key)));
-    return {
-      matched: true,
-      positions: [...new Set(memo.matched ? intersection(memo.positions, info.positions) : info.positions)],
-      optimizedSelector
+import intersection from "./index31.mjs";
+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,
-    positions: [],
+    ids: [],
     optimizedSelector: { ...selector }
   });
 }
-function getIndexInfo(indexProviders, selector) {
-  if (selector == null || Object.keys(selector).length <= 0) {
-    return { matched: false, positions: [], optimizedSelector: selector };
-  }
-  const { $and, $or, ...rest } = selector;
-  const flatInfo = getMergedIndexInfo(indexProviders, rest);
-  let { matched, positions } = flatInfo;
-  const newSelector = flatInfo.optimizedSelector;
-  if (Array.isArray($and)) {
-    const $andNew = [];
-    for (const sel of $and) {
-      const { matched: selMatched, positions: selPositions, optimizedSelector } = getIndexInfo(indexProviders, sel);
+function optimizeLogicGate(queryFunctions, logicGate, idsCallback) {
+  return logicGate.reduce((memoOrPromise, sel) => {
+    const getSelector = (indexInfo) => {
+      const { matched: selMatched, ids: selIds, optimizedSelector: optimizedSelector2 } = indexInfo;
       if (selMatched) {
-        positions = matched ? intersection(positions, selPositions) : selPositions;
-        matched = true;
-        if (Object.keys(optimizedSelector).length > 0) {
-          $andNew.push(optimizedSelector);
+        idsCallback(true, selIds);
+        if (Object.keys(optimizedSelector2).length > 0) {
+          return optimizedSelector2;
         }
       } else {
-        $andNew.push(sel);
+        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;
+      });
     }
-    if ($andNew.length > 0)
-      newSelector.$and = $andNew;
+    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
+    };
   }
-  if (Array.isArray($or)) {
-    const $orNew = [];
-    const matchedBefore = matched;
-    const positionsBefore = positions;
-    let hasNonIndexField = false;
-    for (const sel of $or) {
-      const { matched: selMatched, positions: selPositions, optimizedSelector } = getIndexInfo(indexProviders, sel);
-      if (selMatched) {
-        positions = [.../* @__PURE__ */ new Set([...positions, ...selPositions])];
-        matched = true;
-        if (Object.keys(optimizedSelector).length > 0) {
-          $orNew.push(optimizedSelector);
+  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;
         }
-      } else {
-        $orNew.push(sel);
-        hasNonIndexField = true;
+        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));
     }
-    if ($orNew.length > 0)
-      newSelector.$or = $orNew;
-    if (hasNonIndexField) {
-      newSelector.$or = $or;
-      matched = matchedBefore;
-      positions = positionsBefore;
-    }
-  }
-  return {
-    matched,
-    positions: positions || [],
-    optimizedSelector: newSelector
+    return process$and($andNewOrPromise);
   };
+  if (flatInfoOrPromise instanceof Promise) {
+    return flatInfoOrPromise.then(processFlatInfo);
+  }
+  return processFlatInfo(flatInfoOrPromise);
 }
 export {
   getIndexInfo as default,

package/dist/index23.mjs

@@ -1,84 +1,8 @@
-import Collection from "./index3.mjs";
-import combinePersistenceAdapters from "./index5.mjs";
-import createPersistenceAdapter from "./index8.mjs";
-import createSignal from "./index21.mjs";
-function createReplicationAdapter(options) {
-  return createPersistenceAdapter({
-    async register(onChange) {
-      if (!options.registerRemoteChange)
-        return;
-      await options.registerRemoteChange(onChange);
-    },
-    load: () => options.pull(),
-    save: (items, changes) => {
-      if (!options.push)
-        throw new Error("Pushing is not configured for this collection. Try to pass a `push` function to the collection options.");
-      return options.push(changes, items);
-    }
-  });
-}
-class ReplicatedCollection extends Collection {
-  isPullingRemoteSignal;
-  isPushingRemoteSignal;
-  /**
-   * Creates a new instance of the `ReplicatedCollection` class.
-   * Sets up the replication adapter, combining it with an optional persistence adapter, and
-   * initializes signals for tracking remote pull and push operations.
-   * @param options - The configuration options for the replicated collection.
-   * @param options.pull - A function to fetch data from the remote source.
-   * @param options.push - An optional function to send changes and items to the remote source.
-   * @param options.registerRemoteChange - An optional function to register a listener for remote changes.
-   * @param options.persistence - An optional persistence adapter to combine with replication.
-   * @param options.reactivity - A reactivity adapter for observing changes in the collection.
-   * @param options.transform - A transformation function to apply to items when retrieving them.
-   * @param options.indices - An array of index providers for optimized querying.
-   * @param options.enableDebugMode - A boolean to enable or disable debug mode.
-   */
-  constructor(options) {
-    const replicationAdapter = createReplicationAdapter({
-      registerRemoteChange: options.registerRemoteChange,
-      pull: async () => {
-        this.isPullingRemoteSignal.set(true);
-        try {
-          return await options.pull();
-        } finally {
-          this.isPullingRemoteSignal.set(false);
-        }
-      },
-      push: options.push ? async (changes, items) => {
-        if (!options.push)
-          throw new Error("Pushing is not configured for this collection. Try to pass a `push` function to the collection options.");
-        this.isPushingRemoteSignal.set(true);
-        try {
-          await options.push(changes, items);
-        } finally {
-          this.isPushingRemoteSignal.set(false);
-        }
-      } : void 0
-    });
-    const persistenceAdapter = options?.persistence ? combinePersistenceAdapters(replicationAdapter, options.persistence) : replicationAdapter;
-    super({
-      ...options,
-      persistence: persistenceAdapter
-    });
-    this.isPullingRemoteSignal = createSignal(options.reactivity, false);
-    this.isPushingRemoteSignal = createSignal(options.reactivity, false);
-  }
-  /**
-   * Checks whether the collection is currently performing any loading operation,
-   * including pulling or pushing data from/to the remote source, or standard
-   * persistence adapter operations.
-   * ⚡️ this function is reactive!
-   * @returns A boolean indicating if the collection is currently loading or synchronizing.
-   */
-  isLoading() {
-    const isPullingRemote = this.isPullingRemoteSignal.get();
-    const isPushingRemote = this.isPushingRemoteSignal.get();
-    const isLoading = super.isLoading();
-    return isPullingRemote || isPushingRemote || isLoading;
-  }
+import { Query } from "mingo";
+function match(item, selector) {
+  const query = new Query(selector);
+  return query.test(item);
 }
 export {
-  createReplicationAdapter,
-  ReplicatedCollection as default
+  match as default
 };

package/dist/index24.mjs

@@ -1,19 +1,28 @@
-function get(value, path) {
-  const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
-  if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) {
-    return;
+import get from "./index10.mjs";
+import set from "./index32.mjs";
+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 segments = normalized.split(".");
-  let current = value;
-  for (const key of segments) {
-    if (current == null)
+  const result = {};
+  Object.entries(fields).forEach(([key, value]) => {
+    const fieldValue = get(item, key);
+    if (fieldValue === void 0)
       return;
-    current = current[key];
-  }
-  if (current === void 0)
-    return;
-  return current;
+    if (fieldValue == null && value !== 1)
+      return;
+    set(result, key, value === 1 ? fieldValue : void 0);
+  });
+  return result;
 }
 export {
-  get as default
+  project as default
 };

package/dist/index25.mjs

@@ -1,30 +1,11 @@
-function set(object, path, value, deleteIfUndefined = false) {
-  if (object == null)
-    return object;
-  const segments = path.split(/[.[\]]/g);
-  if (segments[0] === "")
-    segments.shift();
-  if (segments.at(-1) === "")
-    segments.pop();
-  const apply = (node) => {
-    if (segments.length > 1) {
-      const key = segments.shift();
-      const nextIsNumber = !Number.isNaN(Number.parseInt(segments[0], 10));
-      if (node[key] === void 0) {
-        node[key] = nextIsNumber ? [] : {};
-      }
-      apply(node[key]);
-    } else {
-      if (deleteIfUndefined && value === void 0) {
-        delete node[segments[0]];
-        return;
-      }
-      node[segments[0]] = value;
-    }
-  };
-  apply(object);
-  return object;
+import { sort } from "fast-sort";
+import get from "./index10.mjs";
+function sortItems(items, sortFields) {
+  return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
+    const order = value === 1 ? "asc" : "desc";
+    return { [order]: (i) => get(i, key) };
+  }));
 }
 export {
-  set as default
+  sortItems as default
 };