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

package/dist/index18.mjs

@@ -1,27 +1,158 @@
-function createSignal(reactivityAdapter, initialValue, isEqual = Object.is) {
-  let value = initialValue;
-  const dependency = reactivityAdapter?.create();
-  const isInReactiveScope = () => {
-    if (!reactivityAdapter?.isInScope)
-      return true;
-    return reactivityAdapter.isInScope();
-  };
-  const signal = {
-    get() {
-      if (dependency && isInReactiveScope())
-        dependency.depend();
-      return value;
-    },
-    set(newValue) {
-      if (isEqual(value, newValue))
-        return;
-      value = newValue;
-      if (dependency)
-        dependency.notify();
+import isEqual from "./index6.mjs";
+import uniqueBy from "./index30.mjs";
+class Observer {
+  previousItems = [];
+  callbacks;
+  unbindEvents;
+  /**
+   * Creates a new instance of the `Observer` class.
+   * Sets up event bindings and initializes the callbacks for tracking changes in a collection.
+   * @param bindEvents - A function to bind external events to the observer. Must return a cleanup function to unbind those events.
+   */
+  constructor(bindEvents) {
+    this.callbacks = {
+      added: [],
+      addedBefore: [],
+      changed: [],
+      changedField: [],
+      movedBefore: [],
+      removed: []
+    };
+    this.unbindEvents = bindEvents();
+  }
+  call(event, ...args) {
+    this.callbacks[event].forEach(({ callback, options }) => {
+      if (!options.skipInitial || !options.isInitial) {
+        callback(...args);
+      }
+    });
+  }
+  hasCallbacks(events) {
+    return events.some((event) => this.callbacks[event].length > 0);
+  }
+  /**
+   * Determines if the observer has no active callbacks registered for any events.
+   * @returns A boolean indicating whether the observer is empty (i.e., no callbacks are registered).
+   */
+  isEmpty() {
+    return !this.hasCallbacks([
+      "added",
+      "addedBefore",
+      "changed",
+      "changedField",
+      "movedBefore",
+      "removed"
+    ]);
+  }
+  /**
+   * Compares the previous state of items with the new state and triggers the appropriate callbacks
+   * for events such as added, removed, changed, or moved items.
+   * @param getItems - A function that returns a promise resolving to the new items or the items themselves.
+   */
+  runChecks(getItems) {
+    const result = getItems();
+    if (result instanceof Promise) {
+      result.then((newItems) => this.checkItems(newItems)).catch((error) => {
+        console.error("Error while asynchronously querying items", error);
+      });
+    } else {
+      this.checkItems(result);
     }
-  };
-  return signal;
+  }
+  checkItems(newItems) {
+    const oldItemsMap = new Map(this.previousItems.map((item, index) => [
+      item.id,
+      { item, index, beforeItem: this.previousItems[index + 1] || null }
+    ]));
+    const newItemsMap = new Map(newItems.map((item, index) => [
+      item.id,
+      { item, index, beforeItem: newItems[index + 1] || null }
+    ]));
+    if (this.hasCallbacks(["changed", "changedField", "movedBefore", "removed"])) {
+      oldItemsMap.forEach(({ item: oldItem, index, beforeItem: oldBeforeItem }) => {
+        const newItem = newItemsMap.get(oldItem.id);
+        if (newItem) {
+          if (this.hasCallbacks(["changed", "changedField"]) && !isEqual(newItem.item, oldItem)) {
+            this.call("changed", newItem.item);
+            if (this.hasCallbacks(["changedField"])) {
+              const keys = uniqueBy([
+                ...Object.keys(newItem.item),
+                ...Object.keys(oldItem)
+              ], (value) => value);
+              keys.forEach((key) => {
+                if (isEqual(newItem.item[key], oldItem[key]))
+                  return;
+                this.call("changedField", newItem.item, key, oldItem[key], newItem.item[key]);
+              });
+            }
+          }
+          if (newItem.index !== index && newItem.beforeItem?.id !== oldBeforeItem?.id) {
+            this.call("movedBefore", newItem.item, newItem.beforeItem);
+          }
+        } else {
+          this.call("removed", oldItem);
+        }
+      });
+    }
+    if (this.hasCallbacks(["added", "addedBefore"])) {
+      newItems.forEach((newItem, index) => {
+        const oldItem = oldItemsMap.get(newItem.id);
+        if (oldItem)
+          return;
+        this.call("added", newItem);
+        this.call("addedBefore", newItem, newItems[index + 1] || null);
+      });
+    }
+    this.previousItems = newItems;
+    Object.keys(this.callbacks).forEach((key) => {
+      const event = key;
+      const callbacks = this.callbacks[event];
+      this.callbacks[event] = callbacks.map((callback) => ({
+        ...callback,
+        options: {
+          ...callback.options,
+          isInitial: false
+        }
+      }));
+    });
+  }
+  stopped = false;
+  /**
+   * Stops the observer by unbinding all events and cleaning up resources.
+   * Safe to call multiple times - will only unbind once.
+   */
+  stop() {
+    if (this.stopped)
+      return;
+    this.stopped = true;
+    this.unbindEvents();
+  }
+  /**
+   * Registers callbacks for specific events to observe changes in the collection.
+   * @param callbacks - An object containing the callbacks for various events (e.g., 'added', 'removed').
+   * @param skipInitial - A boolean indicating whether to skip invoking the callbacks for the initial state of the collection.
+   */
+  addCallbacks(callbacks, skipInitial = false) {
+    Object.keys(callbacks).forEach((key) => {
+      const typedKey = key;
+      this.callbacks[typedKey].push({
+        callback: callbacks[typedKey],
+        options: { skipInitial, isInitial: true }
+      });
+    });
+  }
+  /**
+   * Removes the specified callbacks for specific events, unregistering them from the observer.
+   * @param callbacks - An object containing the callbacks to be removed for various events.
+   */
+  removeCallbacks(callbacks) {
+    Object.keys(callbacks).forEach((key) => {
+      const typedKey = key;
+      const index = this.callbacks[typedKey].findIndex(({ callback }) => callback === callbacks[typedKey]);
+      this.callbacks[typedKey].splice(index, 1);
+    });
+  }
 }
 export {
-  createSignal as default
+  Observer as default
 };

package/dist/index19.mjs

@@ -1,42 +1,27 @@
-function clone(value) {
-  if (typeof value === "function")
-    throw new Error("Cloning functions is not supported");
-  if (value === null || typeof value !== "object")
-    return value;
-  if (value instanceof Date)
-    return new Date(value);
-  if (Array.isArray(value))
-    return value.map((item) => clone(item));
-  if (value instanceof Map) {
-    const result2 = /* @__PURE__ */ new Map();
-    value.forEach((currentValue, key) => {
-      result2.set(key, clone(currentValue));
-    });
-    return result2;
-  }
-  if (value instanceof Set) {
-    const result2 = /* @__PURE__ */ new Set();
-    value.forEach((currentValue) => {
-      result2.add(clone(currentValue));
-    });
-    return result2;
-  }
-  if (value instanceof RegExp)
-    return new RegExp(value);
-  const result = {};
-  for (const key in value) {
-    if (Object.hasOwnProperty.call(value, key)) {
-      result[key] = clone(value[key]);
+function createSignal(reactivityAdapter, initialValue, isEqual = Object.is) {
+  let value = initialValue;
+  const dependency = reactivityAdapter?.create();
+  const isInReactiveScope = () => {
+    if (!reactivityAdapter?.isInScope)
+      return true;
+    return reactivityAdapter.isInScope();
+  };
+  const signal = {
+    get() {
+      if (dependency && isInReactiveScope())
+        dependency.depend();
+      return value;
+    },
+    set(newValue) {
+      if (isEqual(value, newValue))
+        return;
+      value = newValue;
+      if (dependency)
+        dependency.notify();
     }
-  }
-  return result;
-}
-function deepClone(object) {
-  if (typeof structuredClone === "function")
-    return structuredClone(object);
-  return clone(object);
+  };
+  return signal;
 }
 export {
-  clone,
-  deepClone as default
+  createSignal as default
 };

package/dist/index2.mjs

@@ -1,4 +1,4 @@
-import Observer from "./index17.mjs";
+import Observer from "./index18.mjs";
 function isInReactiveScope(reactivity) {
   if (!reactivity)
     return false;

package/dist/index20.mjs

@@ -1,17 +1,42 @@
-function isEmptyOptions(options) {
-  if (options == null)
-    return true;
-  if (typeof options !== "object")
-    return false;
-  if (Array.isArray(options))
-    return false;
-  return Object.keys(options).length === 0;
+function clone(value) {
+  if (typeof value === "function")
+    throw new Error("Cloning functions is not supported");
+  if (value === null || typeof value !== "object")
+    return value;
+  if (value instanceof Date)
+    return new Date(value);
+  if (Array.isArray(value))
+    return value.map((item) => clone(item));
+  if (value instanceof Map) {
+    const result2 = /* @__PURE__ */ new Map();
+    value.forEach((currentValue, key) => {
+      result2.set(key, clone(currentValue));
+    });
+    return result2;
+  }
+  if (value instanceof Set) {
+    const result2 = /* @__PURE__ */ new Set();
+    value.forEach((currentValue) => {
+      result2.add(clone(currentValue));
+    });
+    return result2;
+  }
+  if (value instanceof RegExp)
+    return new RegExp(value);
+  const result = {};
+  for (const key in value) {
+    if (Object.hasOwnProperty.call(value, key)) {
+      result[key] = clone(value[key]);
+    }
+  }
+  return result;
 }
-function queryId(selector, options) {
-  const selectorId = JSON.stringify(selector);
-  const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
-  return `${selectorId}:${optionsId}`;
+function deepClone(object) {
+  if (typeof structuredClone === "function")
+    return structuredClone(object);
+  return clone(object);
 }
 export {
-  queryId as default
+  clone,
+  deepClone as default
 };

package/dist/index21.mjs

@@ -1,105 +1,17 @@
-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;
-  };
-  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);
-      }
-    },
-    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);
-      }
-    }
-  });
+function isEmptyOptions(options) {
+  if (options == null)
+    return true;
+  if (typeof options !== "object")
+    return false;
+  if (Array.isArray(options))
+    return false;
+  return Object.keys(options).length === 0;
+}
+function queryId(selector, options) {
+  const selectorId = JSON.stringify(selector);
+  const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
+  return `${selectorId}:${optionsId}`;
 }
 export {
-  createIndex as default
+  queryId as default
 };

package/dist/index22.mjs

@@ -1,129 +1,105 @@
-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);
-      });
+import createIndexProvider from "./index34.mjs";
+import get from "./index10.mjs";
+import getMatchingKeys from "./index27.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
 };