@signaldb/core 1.5.3 → 1.6.0

package/dist/index13.mjs

@@ -1,68 +1,139 @@
-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 };
-      let includedPositions = [];
-      if (keys.include == null) {
-        for (const set of index.values()) {
-          for (const pos of set) {
-            includedPositions.push(pos);
-          }
-        }
-      } else {
-        for (const key of keys.include) {
-          const posSet = index.get(key);
-          if (posSet) {
-            for (const pos of posSet) {
-              includedPositions.push(pos);
-            }
-          }
+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);
+    }
+    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);
         }
       }
-      if (keys.exclude != null) {
-        const excludeSet = /* @__PURE__ */ new Set();
-        for (const key of keys.exclude) {
-          const posSet = index.get(key);
-          if (posSet) {
-            for (const pos of posSet) {
-              excludeSet.add(pos);
-            }
-          }
+      this._listenerStore.clear();
+    } else {
+      const listenersSet = this._listenerStore.get(eventName);
+      if (listenersSet) {
+        for (const listener of listenersSet.values()) {
+          this.off(eventName, listener);
         }
-        includedPositions = includedPositions.filter((pos) => !excludeSet.has(pos));
+        this._listenerStore.delete(eventName);
       }
-      return {
-        matched: true,
-        positions: includedPositions,
-        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);
-      });
     }
-  };
+    return this;
+  }
 }
 export {
-  createExternalIndex,
-  createIndex as default
+  EventEmitter as default
 };

package/dist/index14.mjs

@@ -1,8 +1,74 @@
-import { Query } from "mingo";
-function match(item, selector) {
-  const query = new Query(selector);
-  return query.test(item);
+import createIndexProvider from "./index6.mjs";
+import get from "./index24.mjs";
+import getMatchingKeys from "./index28.mjs";
+import serializeValue from "./index20.mjs";
+function createExternalIndex(field, index) {
+  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 includedPositions = [];
+      if (keys.include == null) {
+        for (const set of index.values()) {
+          for (const pos of set) {
+            includedPositions.push(pos);
+          }
+        }
+      } else {
+        for (const key of keys.include) {
+          const posSet = index.get(key);
+          if (posSet) {
+            for (const pos of posSet) {
+              includedPositions.push(pos);
+            }
+          }
+        }
+      }
+      if (keys.exclude != null) {
+        const excludeSet = /* @__PURE__ */ new Set();
+        for (const key of keys.exclude) {
+          const posSet = index.get(key);
+          if (posSet) {
+            for (const pos of posSet) {
+              excludeSet.add(pos);
+            }
+          }
+        }
+        includedPositions = includedPositions.filter((pos) => !excludeSet.has(pos));
+      }
+      return {
+        matched: true,
+        positions: includedPositions,
+        fields: [field],
+        keepSelector: filteresForNull
+      };
+    },
+    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);
+      });
+    }
+  };
 }
 export {
-  match as default
+  createExternalIndex,
+  createIndex as default
 };

package/dist/index15.mjs

@@ -1,43 +1,11 @@
-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);
+import { sort } from "fast-sort";
+import get from "./index24.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 {
-  clone,
-  deepClone as default
+  sortItems as default
 };

package/dist/index16.mjs

@@ -1,14 +1,28 @@
-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);
+import get from "./index24.mjs";
+import set from "./index25.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 {
-  serializeValue as default
+  project as default
 };

package/dist/index17.mjs

@@ -1,27 +1,147 @@
-function createSignal(reactivityAdapter, initialValue, isEqual = Object.is) {
-  let value = initialValue;
-  const dependency = reactivityAdapter == null ? void 0 : reactivityAdapter.create();
-  const isInReactiveScope = () => {
-    if (!(reactivityAdapter == null ? void 0 : 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();
+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 isEqual from "./index10.mjs";
+import uniqueBy from "./index26.mjs";
+class Observer {
+  /**
+   * 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) {
+    __publicField(this, "previousItems", []);
+    __publicField(this, "callbacks");
+    __publicField(this, "unbindEvents");
+    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 newItems - The new list of items to compare against the previous state.
+   */
+  runChecks(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 }) => {
+        var _a;
+        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 && ((_a = newItem.beforeItem) == null ? void 0 : _a.id) !== (oldBeforeItem == null ? void 0 : oldBeforeItem.id)) {
+            this.call("movedBefore", newItem.item, newItem.beforeItem);
+          }
+        } else {
+          this.call("removed", oldItem);
+        }
+      });
     }
-  };
-  return signal;
+    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);
+    });
+  }
 }
 export {
-  createSignal as default
+  Observer as default
 };