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

package/dist/index21.mjs

@@ -1,129 +1,105 @@
-import intersection from "./index28.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);
-      });
+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);
     }
-    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 }
-  });
-}
-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;
+    return set;
+  };
+  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 {
-        idsCallback(false, []);
-        return sel;
+        for (const key of keys.include) {
+          const posSet = index.get(key);
+          if (posSet) {
+            for (const pos of posSet) {
+              includedIds.push(pos);
+            }
+          }
+        }
       }
-    };
-    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;
+      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);
+            }
+          }
         }
-        return {
-          matched,
-          ids: ids || [],
-          optimizedSelector: newSelector
-        };
+        includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
+      }
+      return {
+        matched: true,
+        ids: includedIds,
+        fields: [field],
+        keepSelector: filteresForNull
       };
-      const $orNewOrPromise = Array.isArray($or) ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
-        if (match) {
-          ids = [.../* @__PURE__ */ new Set([...ids, ...selIds])];
-          matched = true;
-        } else {
-          hasNonIndexField = true;
+    },
+    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);
+      }
+    },
+    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);
         }
-      }) : void 0;
-      if ($orNewOrPromise instanceof Promise) {
-        return $orNewOrPromise.then(($orNew) => process$or($orNew));
+        ensureSet(newValue).add(newItem.id);
       }
-      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);
+  });
 }
 export {
-  getIndexInfo as default,
-  getMergedIndexInfo
+  createIndex as default
 };

package/dist/index22.mjs

@@ -1,8 +1,129 @@
-import { Query } from "mingo";
-function match(item, selector) {
-  const query = new Query(selector);
-  return query.test(item);
+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,
+    ids: [],
+    optimizedSelector: { ...selector }
+  });
+}
+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);
 }
 export {
-  match as default
+  getIndexInfo as default,
+  getMergedIndexInfo
 };

package/dist/index23.mjs

@@ -1,28 +1,8 @@
-import get from "./index10.mjs";
-import set from "./index29.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 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;
+import { Query } from "mingo";
+function match(item, selector) {
+  const query = new Query(selector);
+  return query.test(item);
 }
 export {
-  project as default
+  match as default
 };

package/dist/index24.mjs

@@ -1,8 +1,28 @@
-function queryId(selector, options) {
-  const selectorId = JSON.stringify(selector);
-  const optionsId = options == null ? -1 : JSON.stringify(options);
-  return `${selectorId}:${optionsId}`;
+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 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;
 }
 export {
-  queryId as default
+  project as default
 };

package/dist/index26.mjs

@@ -1,4 +1,4 @@
-import isFieldExpression from "./index30.mjs";
+import isFieldExpression from "./index33.mjs";
 import serializeValue from "./index11.mjs";
 function getMatchingKeys(field, selector) {
   const result = { include: null, exclude: null };

package/dist/index27.mjs

@@ -1,6 +1,47 @@
-function createIndexProvider(definition) {
-  return definition;
+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 };
 }
 export {
-  createIndexProvider as default
+  batchOnNextTick as default
 };

package/dist/index28.mjs

@@ -1,8 +1,9 @@
-function intersection(...arrays) {
-  if (arrays.length === 0)
-    return [];
-  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
+function truthy(value) {
+  return !!value;
+}
+function compact(array) {
+  return array.filter(truthy);
 }
 export {
-  intersection as default
+  compact as default
 };

package/dist/index29.mjs

@@ -1,30 +1,10 @@
-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;
+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);
+  });
 }
 export {
-  set as default
+  uniqueBy as default
 };

package/dist/index3.mjs

@@ -4,6 +4,7 @@ import randomId from "./index8.mjs";
 import DefaultDataAdapter from "./index12.mjs";
 import modify from "./index7.mjs";
 import deepClone from "./index19.mjs";
+import queryId from "./index20.mjs";
 import Cursor from "./index2.mjs";
 class Collection extends EventEmitter {
   static collections = [];
@@ -66,6 +67,7 @@ class Collection extends EventEmitter {
   isDisposed = false;
   postBatchCallbacks = /* @__PURE__ */ new Set();
   fieldTracking = false;
+  queryListenersMap = /* @__PURE__ */ new Map();
   constructor(nameOrOptions, maybeDataAdapter, maybeOptions) {
     super();
     const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name || `${this.constructor.name}-${randomId()}`;
@@ -204,21 +206,9 @@ class Collection extends EventEmitter {
     return this.profile(() => {
       if (!options?.async)
         return this.backend.getQueryResult(selector, options);
-      return new Promise((resolve, reject) => {
-        this.isPullingSignal.set(true);
-        const cleanup = this.backend.onQueryStateChange(selector, options, (state) => {
-          if (state === "error") {
-            cleanup();
-            reject(this.backend.getQueryError(selector, options) || new Error("Unknown error"));
-          } else if (state === "complete") {
-            cleanup();
-            resolve(this.backend.getQueryResult(selector, options) || []);
-          }
-        });
-        this.backend.registerQuery(selector, options);
-      }).finally(() => {
+      this.isPullingSignal.set(true);
+      return this.backend.executeQuery(selector, options).finally(() => {
         this.isPullingSignal.set(false);
-        this.backend.unregisterQuery(selector, options);
       });
     }, (measuredTime) => this.executeInDebugMode((callstack) => this.emit("_debug.getItems", callstack, selector, measuredTime)));
   }
@@ -230,6 +220,13 @@ class Collection extends EventEmitter {
       this.isPushingSignal.set(false);
     }
   }
+  queryListeners(query, listeners) {
+    const id = queryId(query.selector, query.options);
+    if (listeners != null) {
+      return this.queryListenersMap.set(id, listeners);
+    }
+    return this.queryListenersMap.get(id) ?? 0;
+  }
   /**
    * Disposes the collection, unregisters persistence adapters, clears memory, and
    * cleans up all resources used by the collection.
@@ -268,17 +265,25 @@ class Collection extends EventEmitter {
           }
           requery();
         };
-        this.backend.registerQuery(selector, options);
-        const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options, (state) => {
+        const listeners = this.queryListeners({ selector, options });
+        if (listeners === 0)
+          this.backend.registerQuery(selector, options || {});
+        this.queryListeners({ selector, options }, listeners + 1);
+        const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options || {}, (state) => {
           if (state !== "complete")
             return;
           handleRequery();
         });
         this.emit("observer.created", selector, options);
         return () => {
-          this.backend.unregisterQuery(selector, options);
-          queryStateChangeCleanup();
-          this.emit("observer.disposed", selector, options);
+          setTimeout(() => {
+            const newListeners = Math.max(0, this.queryListeners({ selector, options }) - 1);
+            if (newListeners === 0)
+              this.backend.unregisterQuery(selector, options || {});
+            this.queryListeners({ selector, options }, newListeners);
+            queryStateChangeCleanup();
+            this.emit("observer.disposed", selector, options);
+          }, 0);
         };
       }
     });
@@ -371,9 +376,8 @@ class Collection extends EventEmitter {
       throw new Error("Collection is disposed");
     if (!items)
       throw new Error("Invalid items");
-    if (items.length === 0) {
+    if (items.length === 0)
       return [];
-    }
     const ids = [];
     await this.batch(async () => {
       await Promise.all(items.map(async (item) => {