@signaldb/core 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/index17.cjs.js

@@ -0,0 +1,47 @@
+//#region src/utils/deepClone.ts
+/**
+* Performs a deep clone of a value, supporting various types including arrays, objects,
+* Maps, Sets, Dates, and RegExps. Functions are not supported and will throw an error.
+* @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 {Error} An error if the value is a function, as cloning functions is not supported.
+*/
+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 result = /* @__PURE__ */ new Map();
+		value.forEach((currentValue, key) => {
+			result.set(key, clone(currentValue));
+		});
+		return result;
+	}
+	if (value instanceof Set) {
+		const result = /* @__PURE__ */ new Set();
+		value.forEach((currentValue) => {
+			result.add(clone(currentValue));
+		});
+		return result;
+	}
+	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;
+}
+/**
+* Creates a deep clone of an object. Uses the `structuredClone` function if available,
+* otherwise falls back to a manual deep clone implementation.
+* @template T - The type of the object to clone.
+* @param object - The object to deep clone.
+* @returns A deep copy of the provided object.
+*/
+function deepClone(object) {
+	if (typeof structuredClone === "function") return structuredClone(object);
+	/* istanbul ignore next -- @preserve */
+	return clone(object);
+}
+//#endregion
+exports.default = deepClone;

package/dist/index17.mjs

@@ -1,151 +1,47 @@
-import isEqual from "./index6.mjs";
-import uniqueBy from "./index29.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) {
-      void result.then((newItems) => this.checkItems(newItems));
-    } 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);
-    });
-  }
+//#region src/utils/deepClone.ts
+/**
+* Performs a deep clone of a value, supporting various types including arrays, objects,
+* Maps, Sets, Dates, and RegExps. Functions are not supported and will throw an error.
+* @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 {Error} An error if the value is a function, as cloning functions is not supported.
+*/
+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 result = /* @__PURE__ */ new Map();
+		value.forEach((currentValue, key) => {
+			result.set(key, clone(currentValue));
+		});
+		return result;
+	}
+	if (value instanceof Set) {
+		const result = /* @__PURE__ */ new Set();
+		value.forEach((currentValue) => {
+			result.add(clone(currentValue));
+		});
+		return result;
+	}
+	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;
 }
-export {
-  Observer as default
-};
+/**
+* Creates a deep clone of an object. Uses the `structuredClone` function if available,
+* otherwise falls back to a manual deep clone implementation.
+* @template T - The type of the object to clone.
+* @param object - The object to deep clone.
+* @returns A deep copy of the provided object.
+*/
+function deepClone(object) {
+	if (typeof structuredClone === "function") return structuredClone(object);
+	/* istanbul ignore next -- @preserve */
+	return clone(object);
+}
+//#endregion
+export { deepClone as default };

package/dist/index18.cjs.js

@@ -0,0 +1,15 @@
+let mingo = require("mingo");
+//#region src/utils/match.ts
+/**
+* Tests whether a given item matches a specified selector.
+* Uses the `mingo` library to evaluate the query.
+* @template T - The type of the item being tested.
+* @param item - The item to test against the selector.
+* @param selector - The query selector used to match the item.
+* @returns A boolean indicating whether the item matches the selector.
+*/
+function match(item, selector) {
+	return new mingo.Query(selector).test(item);
+}
+//#endregion
+exports.default = match;

package/dist/index18.mjs

@@ -1,27 +1,15 @@
-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;
+import { Query } from "mingo";
+//#region src/utils/match.ts
+/**
+* Tests whether a given item matches a specified selector.
+* Uses the `mingo` library to evaluate the query.
+* @template T - The type of the item being tested.
+* @param item - The item to test against the selector.
+* @param selector - The query selector used to match the item.
+* @returns A boolean indicating whether the item matches the selector.
+*/
+function match(item, selector) {
+	return new Query(selector).test(item);
 }
-export {
-  createSignal as default
-};
+//#endregion
+export { match as default };

package/dist/index19.cjs.js

@@ -0,0 +1,23 @@
+const require_deepClone = require("./index17.cjs.js");
+let mingo = require("mingo");
+//#region src/utils/modify.ts
+/**
+* Applies a modifier to an object and returns a new modified object.
+* @template T - The type of the object to be modified.
+* @param item - The object to be modified.
+* @param modifier - The modifier to apply. This can be any transformation logic.
+* @returns - Returns a new object with the modifications applied.
+* @example
+* const item = { a: 1, b: 2 }
+* const modifier = { $set: { b: 3, c: 4 } }
+* const result = modify(item, modifier)
+* // result: { a: 1, b: 3, c: 4 }
+*/
+function modify(item, modifier) {
+	if (!Object.keys(modifier).some((key) => key.startsWith("$"))) return modifier;
+	const clonedItem = require_deepClone.default(item);
+	(0, mingo.update)(clonedItem, modifier);
+	return clonedItem;
+}
+//#endregion
+exports.default = modify;

package/dist/index19.mjs

@@ -1,43 +1,23 @@
-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;
+import deepClone from "./index17.mjs";
+import { update } from "mingo";
+//#region src/utils/modify.ts
+/**
+* Applies a modifier to an object and returns a new modified object.
+* @template T - The type of the object to be modified.
+* @param item - The object to be modified.
+* @param modifier - The modifier to apply. This can be any transformation logic.
+* @returns - Returns a new object with the modifications applied.
+* @example
+* const item = { a: 1, b: 2 }
+* const modifier = { $set: { b: 3, c: 4 } }
+* const result = modify(item, modifier)
+* // result: { a: 1, b: 3, c: 4 }
+*/
+function modify(item, modifier) {
+	if (!Object.keys(modifier).some((key) => key.startsWith("$"))) return modifier;
+	const clonedItem = deepClone(item);
+	update(clonedItem, modifier);
+	return clonedItem;
 }
-function deepClone(object) {
-  if (typeof structuredClone === "function")
-    return structuredClone(object);
-  /* istanbul ignore next -- @preserve */
-  return clone(object);
-}
-export {
-  clone,
-  deepClone as default
-};
+//#endregion
+export { modify as default };

package/dist/index2.cjs.js

@@ -0,0 +1,33 @@
+//#region src/utils/isEqual.ts
+/**
+* Compares two values for deep equality.
+* @param a - The first value to compare.
+* @param b - The second value to compare.
+* @returns - Returns `true` if the two values are deeply equal, otherwise `false`.
+* @example
+* isEqual({ a: 1 }, { a: 1 }); // true
+* isEqual([1, 2], [1, 2]);     // true
+* isEqual(new Date(0), new Date(0)); // true
+* isEqual(/abc/, /abc/);       // true
+* isEqual({ a: 1 }, { a: 2 }); // false
+* isEqual(null, null);         // true
+*/
+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;
+}
+//#endregion
+exports.default = isEqual;