@signaldb/core 1.2.3 → 1.3.0

package/dist/index13.mjs

@@ -1,139 +1,44 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-class EventEmitter {
-  constructor() {
-    __publicField(this, "_maxListeners", 100);
-    /**
-     * We store a set of the listeners for each event.
-     */
-    __publicField(this, "_listenerStore", /* @__PURE__ */ new Map());
-  }
-  setMaxListeners(max) {
-    this._maxListeners = max;
-    return this;
-  }
-  /**
-   * Subscribe to an event with a listener function.
-   * @param eventName The event name (key of E).
-   * @param listener  A function that receives the emitted arguments.
-   * @returns         The emitter instance (for chaining).
-   */
-  on(eventName, listener) {
-    let listenersSet = this._listenerStore.get(eventName);
-    if (!listenersSet) {
-      listenersSet = /* @__PURE__ */ new Set();
-      this._listenerStore.set(eventName, listenersSet);
+import createIndexProvider from "./index5.mjs";
+import get from "./index25.mjs";
+import getMatchingKeys from "./index26.mjs";
+import serializeValue from "./index16.mjs";
+function createExternalIndex(field, index) {
+  return createIndexProvider({
+    query(selector) {
+      const keys = getMatchingKeys(field, selector);
+      if (keys.include == null && keys.exclude == null)
+        return { matched: false };
+      const includedKeys = keys.include == null ? [...index.values()].reduce((memo, set) => [...memo, ...set], []) : keys.include.reduce((memo, key) => [...memo, ...index.get(key) || []], []);
+      const itemPositions = keys.exclude == null ? includedKeys : keys.exclude.reduce((memo, key) => memo.filter((i) => {
+        var _a;
+        return !((_a = index.get(key)) == null ? void 0 : _a.has(i));
+      }), includedKeys);
+      return {
+        matched: true,
+        positions: itemPositions,
+        fields: [field]
+      };
+    },
+    rebuild() {
     }
-    listenersSet.add(listener);
-    if (listenersSet.size > this._maxListeners) {
-      console.warn(`Possible EventEmitter memory leak detected. ${listenersSet.size} ${String(eventName)} listeners added. Use emitter.setMaxListeners() to increase limit.`);
-    }
-    return this;
-  }
-  /**
-   * Subscribe to an event with a listener function.
-   * @param eventName The event name (key of E).
-   * @param listener  A function that receives the emitted arguments.
-   * @returns         The emitter instance (for chaining).
-   */
-  addListener(eventName, listener) {
-    return this.on(eventName, listener);
-  }
-  /**
-   * Subscribe to an event, handling it only once. Automatically removes
-   * the listener after it fires the first time.
-   * @param eventName The event name (key of E).
-   * @param listener  A function that receives the emitted arguments.
-   * @returns         The emitter instance (for chaining).
-   */
-  once(eventName, listener) {
-    const onceWrapper = (...args) => {
-      listener(...args);
-      this.off(eventName, onceWrapper);
-    };
-    return this.on(eventName, onceWrapper);
-  }
-  /**
-   * Unsubscribe a previously subscribed listener.
-   * @param eventName The event name (key of E).
-   * @param listener  The original function passed to `on` or `once`.
-   * @returns         The emitter instance (for chaining).
-   */
-  off(eventName, listener) {
-    const listenersSet = this._listenerStore.get(eventName);
-    if (!listenersSet)
-      return this;
-    listenersSet.delete(listener);
-    if (listenersSet.size === 0) {
-      this._listenerStore.delete(eventName);
-    }
-    return this;
-  }
-  /**
-   * Unsubscribe a previously subscribed listener.
-   * @param eventName The event name (key of E).
-   * @param listener  The original function passed to `on` or `once`.
-   * @returns         The emitter instance (for chaining).
-   */
-  removeListener(eventName, listener) {
-    return this.off(eventName, listener);
-  }
-  /**
-   * Emit (dispatch) an event with a variable number of arguments.
-   * @param eventName The event name (key of E).
-   * @param args      The arguments to pass to subscribed listeners.
-   */
-  emit(eventName, ...args) {
-    this.listeners(eventName).forEach((listener) => {
-      listener(...args);
-    });
-  }
-  /**
-   * Returns the array of listener functions currently registered for a given event.
-   * @param eventName The event name (key of E).
-   * @returns         An array of listener functions.
-   */
-  listeners(eventName) {
-    const listenersSet = this._listenerStore.get(eventName);
-    if (!listenersSet)
-      return [];
-    return [...listenersSet.values()];
-  }
-  /**
-   * Returns the number of listeners for a given event.
-   * @param eventName The event name (key of E).
-   * @returns         The number of listeners.
-   */
-  listenerCount(eventName) {
-    const listenersSet = this._listenerStore.get(eventName);
-    return listenersSet ? listenersSet.size : 0;
-  }
-  /**
-   * Removes all listeners for a given event, or all events if none is specified.
-   * @param eventName Optional. If omitted, clears all events’ listeners.
-   * @returns         The emitter instance (for chaining).
-   */
-  removeAllListeners(eventName) {
-    if (eventName === void 0) {
-      for (const [eventName_, listenersSet] of this._listenerStore.entries()) {
-        for (const listener of listenersSet.values()) {
-          this.off(eventName_, listener);
-        }
-      }
-      this._listenerStore.clear();
-    } else {
-      const listenersSet = this._listenerStore.get(eventName);
-      if (listenersSet) {
-        for (const listener of listenersSet.values()) {
-          this.off(eventName, listener);
-        }
-        this._listenerStore.delete(eventName);
-      }
+  });
+}
+function createIndex(field) {
+  const index = /* @__PURE__ */ new Map();
+  return {
+    ...createExternalIndex(field, index),
+    rebuild(items) {
+      index.clear();
+      items.forEach((item, i) => {
+        const value = serializeValue(get(item, field));
+        const current = index.get(value) || /* @__PURE__ */ new Set();
+        current.add(i);
+        index.set(value, current);
+      });
     }
-    return this;
-  }
+  };
 }
 export {
-  EventEmitter as default
+  createExternalIndex,
+  createIndex as default
 };

package/dist/index14.mjs

@@ -1,40 +1,8 @@
-import createIndexProvider from "./index6.mjs";
-import get from "./index27.mjs";
-import getMatchingKeys from "./index28.mjs";
-import serializeValue from "./index18.mjs";
-function createExternalIndex(field, index) {
-  return createIndexProvider({
-    query(selector) {
-      const keys = getMatchingKeys(field, selector);
-      if (keys == null)
-        return { matched: false };
-      const itemPositions = keys.reduce((memo, key) => [...memo, ...index.get(key) || []], []);
-      return {
-        matched: true,
-        positions: itemPositions,
-        fields: [field]
-      };
-    },
-    rebuild() {
-    }
-  });
-}
-function createIndex(field) {
-  const index = /* @__PURE__ */ new Map();
-  return {
-    ...createExternalIndex(field, index),
-    rebuild(items) {
-      index.clear();
-      items.forEach((item, i) => {
-        const value = serializeValue(get(item, field));
-        const current = index.get(value) || /* @__PURE__ */ new Set();
-        current.add(i);
-        index.set(value, current);
-      });
-    }
-  };
+import { Query } from "mingo";
+function match(item, selector) {
+  const query = new Query(selector);
+  return query.test(item);
 }
 export {
-  createExternalIndex,
-  createIndex as default
+  match as default
 };

package/dist/index15.mjs

@@ -1,4 +1,43 @@
-const __viteBrowserExternal = {};
+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);
+  /* istanbul ignore next -- @preserve */
+  return clone(object);
+}
 export {
-  __viteBrowserExternal as default
+  clone,
+  deepClone as default
 };

package/dist/index16.mjs

@@ -1,8 +1,14 @@
-import { Query } from "mingo";
-function match(item, selector) {
-  const query = new Query(selector);
-  return query.test(item);
+function serializeValue(value) {
+  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);
 }
 export {
-  match as default
+  serializeValue as default
 };

package/dist/index17.mjs

@@ -1,43 +1,21 @@
-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.getTime());
-  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(dependency, initialValue, isEqual = Object.is) {
+  let value = initialValue;
+  const signal = {
+    get() {
+      if (dependency)
+        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);
-  /* istanbul ignore next -- @preserve */
-  return clone(object);
+  };
+  return signal;
 }
 export {
-  clone,
-  deepClone as default
+  createSignal as default
 };

package/dist/index18.mjs

@@ -1,14 +1,264 @@
-function serializeValue(value) {
-  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);
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import sortItems from "./index21.mjs";
+import project from "./index22.mjs";
+import Observer from "./index23.mjs";
+function isInReactiveScope(reactivity) {
+  if (!reactivity)
+    return false;
+  if (!reactivity.isInScope)
+    return true;
+  return reactivity.isInScope();
+}
+class Cursor {
+  /**
+   * 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.
+   */
+  constructor(getItems, options) {
+    __publicField(this, "observer");
+    __publicField(this, "getFilteredItems");
+    __publicField(this, "options");
+    __publicField(this, "onCleanupCallbacks", []);
+    this.getFilteredItems = 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);
+  }
+  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)
+      return;
+    if (!isInReactiveScope(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.
+   */
+  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));
+    });
+  }
+  /**
+   * 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 = [];
+    this.forEach((item) => {
+      results.push(callback(item));
+    });
+    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() {
+    const items = this.getItems();
+    this.depend({
+      added: true,
+      removed: true
+    });
+    return items.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());
+  }
 }
 export {
-  serializeValue as default
+  Cursor as default,
+  isInReactiveScope
 };