@signaldb/core 1.7.2 → 1.8.1

package/dist/index9.cjs.js

@@ -0,0 +1,139 @@
+const require_isEqual = require("./index7.cjs.js");
+const require_uniqueBy = require("./index8.cjs.js");
+//#region src/Collection/Observer.ts
+/**
+* Represents an observer that tracks changes in a collection of items and triggers
+* callbacks for various events such as addition, removal, and modification of items.
+* @template T - The type of the items being observed, which must include an `id` field.
+*/
+var Observer = class {
+	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 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 }) => {
+			const newItem = newItemsMap.get(oldItem.id);
+			if (newItem) {
+				if (this.hasCallbacks(["changed", "changedField"]) && !require_isEqual.default(newItem.item, oldItem)) {
+					this.call("changed", newItem.item);
+					if (this.hasCallbacks(["changedField"])) require_uniqueBy.default([...Object.keys(newItem.item), ...Object.keys(oldItem)], (value) => value).forEach((key) => {
+						if (require_isEqual.default(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) => {
+			if (oldItemsMap.get(newItem.id)) 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);
+		});
+	}
+};
+//#endregion
+exports.default = Observer;

package/dist/index9.mjs

@@ -1,6 +1,139 @@
-function createReactivityAdapter(definition) {
-  return definition;
-}
-export {
-  createReactivityAdapter as default
+import isEqual from "./index7.mjs";
+import uniqueBy from "./index8.mjs";
+//#region src/Collection/Observer.ts
+/**
+* Represents an observer that tracks changes in a collection of items and triggers
+* callbacks for various events such as addition, removal, and modification of items.
+* @template T - The type of the items being observed, which must include an `id` field.
+*/
+var Observer = class {
+	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 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 }) => {
+			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"])) uniqueBy([...Object.keys(newItem.item), ...Object.keys(oldItem)], (value) => value).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) => {
+			if (oldItemsMap.get(newItem.id)) 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);
+		});
+	}
 };
+//#endregion
+export { Observer as default };

package/dist/utils/deepClone.d.ts

@@ -4,7 +4,7 @@
  * @template T - The type of the value to clone.
  * @param value - The value to deep clone.
  * @returns A deep copy of the provided value.
- * @throws An error if the value is a function, as cloning functions is not supported.
+ * @throws {Error} An error if the value is a function, as cloning functions is not supported.
  */
 export declare function clone<T>(value: T): T;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaldb/core",
-  "version": "1.7.2",
+  "version": "1.8.1",
   "description": "SignalDB is a client-side database that provides a simple MongoDB-like interface to the data with first-class typescript support to achieve an optimistic UI. Data persistence can be achieved by using storage providers that store the data through a JSON interface to places such as localStorage.",
   "scripts": {
     "build": "rimraf dist && vite build",
@@ -55,9 +55,9 @@
   ],
   "dependencies": {
     "fast-sort": "^3.4.1",
-    "mingo": "^7.0.0"
+    "mingo": "^7.1.1"
   },
   "devDependencies": {
-    "zod": "^4.0.14"
+    "zod": "^4.3.5"
   }
 }

package/dist/index.cjs10.js

@@ -1,29 +0,0 @@
-"use strict";
-function isEqual(a, b) {
-  if (Object.is(a, b))
-    return true;
-  if (a instanceof RegExp && b instanceof RegExp)
-    return a.toString() === b.toString();
-  if (a instanceof Date && b instanceof Date)
-    return a.getTime() === b.getTime();
-  if (typeof a !== "object")
-    return false;
-  if (typeof b !== "object")
-    return false;
-  if (a === null)
-    return false;
-  if (b === null)
-    return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length)
-    return false;
-  for (const key of aKeys) {
-    if (!bKeys.includes(key))
-      return false;
-    if (!isEqual(a[key], b[key]))
-      return false;
-  }
-  return true;
-}
-module.exports = isEqual;

package/dist/index.cjs11.js

@@ -1,12 +0,0 @@
-"use strict";
-const mingo = require("mingo");
-const deepClone = require("./index.cjs19.js");
-function modify(item, modifier) {
-  const hasOperators = Object.keys(modifier).some((key) => key.startsWith("$"));
-  if (!hasOperators)
-    return modifier;
-  const clonedItem = deepClone.default(item);
-  mingo.update(clonedItem, modifier);
-  return clonedItem;
-}
-module.exports = modify;

package/dist/index.cjs12.js

@@ -1,5 +0,0 @@
-"use strict";
-function randomId() {
-  return Math.floor(Math.random() * 1e17).toString(16);
-}
-module.exports = randomId;

package/dist/index.cjs13.js

@@ -1,133 +0,0 @@
-"use strict";
-class EventEmitter {
-  _maxListeners = 100;
-  /**
-   * We store a set of the listeners for each event.
-   */
-  _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);
-        }
-      }
-      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);
-      }
-    }
-    return this;
-  }
-}
-module.exports = EventEmitter;

package/dist/index.cjs14.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const createIndexProvider = require("./index.cjs6.js");
-const get = require("./index.cjs24.js");
-const getMatchingKeys = require("./index.cjs28.js");
-const serializeValue = require("./index.cjs20.js");
-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);
-      });
-    }
-  };
-}
-exports.createExternalIndex = createExternalIndex;
-exports.default = createIndex;

package/dist/index.cjs15.js

@@ -1,10 +0,0 @@
-"use strict";
-const fastSort = require("fast-sort");
-const get = require("./index.cjs24.js");
-function sortItems(items, sortFields) {
-  return fastSort.sort(items).by(Object.entries(sortFields).map(([key, value]) => {
-    const order = value === 1 ? "asc" : "desc";
-    return { [order]: (i) => get(i, key) };
-  }));
-}
-module.exports = sortItems;

package/dist/index.cjs16.js

@@ -1,27 +0,0 @@
-"use strict";
-const get = require("./index.cjs24.js");
-const set = require("./index.cjs25.js");
-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;
-}
-module.exports = project;