@signaldb/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/index.cjs17.js

@@ -1,152 +0,0 @@
-"use strict";
-const isEqual = require("./index.cjs6.js");
-const uniqueBy = require("./index.cjs32.js");
-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);
-    }
-  }
-  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
-        }
-      }));
-    });
-  }
-  /**
-   * Stops the observer by unbinding all events and cleaning up resources.
-   */
-  stop() {
-    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);
-    });
-  }
-}
-module.exports = Observer;

package/dist/index.cjs18.js

@@ -1,26 +0,0 @@
-"use strict";
-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 signal;
-}
-module.exports = createSignal;

package/dist/index.cjs19.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-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 deepClone(object) {
-  if (typeof structuredClone === "function")
-    return structuredClone(object);
-  return clone(object);
-}
-exports.clone = clone;
-exports.default = deepClone;

package/dist/index.cjs2.js

@@ -1,259 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const Observer = require("./index.cjs17.js");
-function isInReactiveScope(reactivity) {
-  if (!reactivity)
-    return false;
-  if (!reactivity.isInScope)
-    return true;
-  return reactivity.isInScope();
-}
-class Cursor {
-  observer;
-  getItems;
-  options;
-  onCleanupCallbacks = [];
-  /**
-   * Creates a new instance of the `Cursor` class.
-   * Provides utilities for querying, observing, and transforming items from a collection.
-   * @template T - The type of the items in the collection.
-   * @template U - The transformed item type after applying transformations (default is T).
-   * @param getItems - A function that retrieves the filtered list of items.
-   * @param options - Optional configuration for the cursor.
-   * @param options.transform - A transformation function to apply to each item when retrieving them.
-   * @param options.bindEvents - A function to bind reactivity events for the cursor, which should return a cleanup function.
-   * @param options.fields - A projection object defining which fields of the item should be included or excluded.
-   * @param options.sort - A sort specifier to determine the order of the items.
-   * @param options.skip - The number of items to skip from the beginning of the result set.
-   * @param options.limit - The maximum number of items to return in the result set.
-   * @param options.reactive - A reactivity adapter to enable observing changes in the cursor's result set.
-   * @param options.fieldTracking - A boolean to enable fine-grained field tracking for reactivity.
-   * @param options.transformAll - A function that will be able to solve the n+1 problem
-   */
-  constructor(getItems, options) {
-    this.getItems = getItems;
-    this.options = options || {};
-  }
-  addGetters(item) {
-    if (!isInReactiveScope(this.options.reactive))
-      return item;
-    const depend = this.depend.bind(this);
-    return Object.entries(item).reduce((memo, [key, value]) => {
-      Object.defineProperty(memo, key, {
-        get() {
-          depend({
-            changedField: (notify) => (changedItem, changedFieldName) => {
-              if (changedFieldName !== key || changedItem.id !== item.id)
-                return;
-              notify();
-            }
-          });
-          return value;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      return memo;
-    }, {});
-  }
-  transform(rawItem) {
-    const item = this.options.fieldTracking ? this.addGetters(rawItem) : rawItem;
-    if (!this.options.transform)
-      return item;
-    return this.options.transform(item);
-  }
-  depend(changeEvents) {
-    if (this.options?.async)
-      return;
-    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();
-    const notify = () => signal.notify();
-    function buildNotifier(event) {
-      const eventHandler = changeEvents[event];
-      return (...args) => {
-        if (eventHandler === true) {
-          notify();
-          return;
-        }
-        if (typeof eventHandler !== "function")
-          return;
-        eventHandler(notify)(...args);
-      };
-    }
-    const stop = this.observeRawChanges({
-      added: buildNotifier("added"),
-      addedBefore: buildNotifier("addedBefore"),
-      changed: buildNotifier("changed"),
-      changedField: buildNotifier("changedField"),
-      movedBefore: buildNotifier("movedBefore"),
-      removed: buildNotifier("removed")
-    }, true);
-    if (this.options.reactive.onDispose) {
-      this.options.reactive.onDispose(() => stop(), signal);
-    }
-    this.onCleanup(stop);
-  }
-  ensureObserver() {
-    if (!this.observer) {
-      const observer = new Observer(() => {
-        const requery = () => {
-          observer.runChecks(this.getItems);
-        };
-        const cleanup = this.options.bindEvents && this.options.bindEvents(requery);
-        return () => {
-          if (cleanup)
-            cleanup();
-        };
-      });
-      this.onCleanup(() => observer.stop());
-      this.observer = observer;
-    }
-    return this.observer;
-  }
-  observeRawChanges(callbacks, skipInitial = false) {
-    const observer = this.ensureObserver();
-    observer.addCallbacks(callbacks, skipInitial);
-    observer.runChecks(this.getItems);
-    return () => {
-      observer.removeCallbacks(callbacks);
-      if (!observer.isEmpty())
-        return;
-      observer.stop();
-      this.observer = void 0;
-    };
-  }
-  /**
-   * Cleans up all resources associated with the cursor, such as reactive bindings
-   * and event listeners. This method should be called when the cursor is no longer needed
-   * to prevent memory leaks.
-   */
-  cleanup() {
-    this.onCleanupCallbacks.forEach((callback) => {
-      callback();
-    });
-    this.onCleanupCallbacks = [];
-  }
-  /**
-   * Registers a cleanup callback to be executed when the `cleanup` method is called.
-   * Useful for managing resources and ensuring proper cleanup of bindings or listeners.
-   * @param callback - A function to be executed during cleanup.
-   */
-  onCleanup(callback) {
-    this.onCleanupCallbacks.push(callback);
-  }
-  /**
-   * Iterates over each item in the cursor's result set, applying the provided callback
-   * function to each transformed item.
-   * ⚡️ 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) {
-    this.depend({
-      addedBefore: true,
-      removed: true,
-      movedBefore: true,
-      ...this.options.fieldTracking ? {} : { changed: true }
-    });
-    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
-   * function to each transformed item in the cursor's result set.
-   * ⚡️ this function is reactive!
-   * @template V - The type of the items in the resulting array.
-   * @param callback - A function to execute for each item in the result set.
-   * @param callback.item - The transformed item.
-   * @returns An array of results after applying the callback to each item.
-   */
-  map(callback) {
-    const results = [];
-    const maybePromise = this.forEach((item) => {
-      results.push(callback(item));
-    });
-    if (maybePromise instanceof Promise) {
-      return maybePromise.then(() => results);
-    }
-    return results;
-  }
-  /**
-   * Fetches all transformed items from the cursor's result set as an array.
-   * Automatically applies filtering, sorting, and limiting as per the cursor's options.
-   * ⚡️ this function is reactive!
-   * @returns An array of transformed items in the result set.
-   */
-  fetch() {
-    return this.map((item) => item);
-  }
-  /**
-   * Counts the total number of items in the cursor's result set after applying
-   * filtering and other criteria.
-   * ⚡️ this function is reactive!
-   * @returns The total number of items in the result set.
-   */
-  count() {
-    this.depend({
-      added: true,
-      removed: true
-    });
-    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
-   * when items are added, removed, or updated. Supports reactivity and transformation.
-   * @param callbacks - An object containing the callback functions to handle different change events.
-   * @param callbacks.added - Triggered when an item is added to the result set.
-   * @param callbacks.removed - Triggered when an item is removed from the result set.
-   * @param callbacks.changed - Triggered when an item in the result set is modified.
-   * @param callbacks.addedBefore - Triggered when an item is added before another item in the result set.
-   * @param callbacks.movedBefore - Triggered when an item is moved before another item in the result set.
-   * @param callbacks.changedField - Triggered when a specific field of an item changes.
-   * @param skipInitial - A boolean indicating whether to skip the initial notification of the current result set.
-   * @returns A function to stop observing changes.
-   */
-  observeChanges(callbacks, skipInitial = false) {
-    return this.observeRawChanges(Object.entries(callbacks).reduce((memo, [callbackName, callback]) => {
-      if (!callback)
-        return memo;
-      return {
-        ...memo,
-        [callbackName]: (item, before) => {
-          const transformedValue = this.transform(item);
-          const hasBeforeParameter = before !== void 0;
-          const transformedBeforeValue = hasBeforeParameter && before ? this.transform(before) : null;
-          return callback(transformedValue, ...hasBeforeParameter ? [transformedBeforeValue] : []);
-        }
-      };
-    }, {}), skipInitial);
-  }
-  /**
-   * Forces the cursor to re-evaluate its result set by re-fetching items
-   * from the collection. This is useful when the underlying data or query
-   * criteria have changed, and you want to ensure the cursor reflects the latest state.
-   */
-  requery() {
-    if (!this.observer)
-      return;
-    this.observer.runChecks(this.getItems);
-  }
-}
-exports.default = Cursor;
-exports.isInReactiveScope = isInReactiveScope;

package/dist/index.cjs20.js

@@ -1,16 +0,0 @@
-"use strict";
-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}`;
-}
-module.exports = queryId;

package/dist/index.cjs21.js

@@ -1,104 +0,0 @@
-"use strict";
-const createIndexProvider = require("./index.cjs33.js");
-const get = require("./index.cjs10.js");
-const getMatchingKeys = require("./index.cjs26.js");
-const serializeValue = require("./index.cjs11.js");
-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);
-      }
-    }
-  });
-}
-module.exports = createIndex;