@signaldb/core 1.7.2 → 1.8.1

package/dist/index17.mjs

@@ -1,143 +1,15 @@
-import isEqual from "./index10.mjs";
-import uniqueBy from "./index26.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 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"])) {
-              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/intersection.ts
+/**
+* Computes the intersection of multiple arrays, returning an array of unique elements
+* that are present in all the input arrays.
+* @template T - The type of elements in the arrays.
+* @param arrays - A variable number of arrays to compute the intersection of.
+* @returns An array containing the unique elements found in all the input arrays.
+*   - If no arrays are provided, returns an empty array.
+*/
+function intersection(...arrays) {
+	if (arrays.length === 0) return [];
+	return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
 }
-export {
-  Observer as default
-};
+//#endregion
+export { intersection as default };

package/dist/index18.cjs.js

@@ -0,0 +1,98 @@
+const require_intersection = require("./index17.cjs.js");
+//#region src/Collection/getIndexInfo.ts
+/**
+* Retrieves merged index information for a given flat selector by querying multiple
+* index providers. Combines results from all index providers to determine matched positions
+* and an optimized selector.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param indexProviders - An array of index providers to query.
+* @param selector - The flat selector used to filter items.
+* @returns An object containing:
+*   - `matched`: A boolean indicating if the selector matched any items.
+*   - `positions`: An array of matched item positions.
+*   - `optimizedSelector`: A flat selector optimized based on the index results.
+*/
+function getMergedIndexInfo(indexProviders, selector) {
+	return indexProviders.reduce((memo, indexProvider) => {
+		const info = indexProvider.query(selector);
+		if (!info.matched) return memo;
+		const optimizedSelector = info.keepSelector ? memo.optimizedSelector : Object.fromEntries(Object.entries(memo.optimizedSelector).filter(([key]) => !info.fields.includes(key)));
+		return {
+			matched: true,
+			positions: [...new Set(memo.matched ? require_intersection.default(memo.positions, info.positions) : info.positions)],
+			optimizedSelector
+		};
+	}, {
+		matched: false,
+		positions: [],
+		optimizedSelector: { ...selector }
+	});
+}
+/**
+* Retrieves index information for a given complex selector by querying multiple
+* index providers. Handles nested `$and` and `$or` conditions in the selector and
+* optimizes the selector to minimize processing overhead.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param indexProviders - An array of index providers to query.
+* @param selector - The complex selector used to filter items.
+* @returns An object containing:
+*   - `matched`: A boolean indicating if the selector matched any items.
+*   - `positions`: An array of matched item positions.
+*   - `optimizedSelector`: A selector optimized based on the index results, with unused
+*     conditions removed.
+*/
+function getIndexInfo(indexProviders, selector) {
+	if (selector == null || Object.keys(selector).length <= 0) return {
+		matched: false,
+		positions: [],
+		optimizedSelector: selector
+	};
+	const { $and, $or, ...rest } = selector;
+	const flatInfo = getMergedIndexInfo(indexProviders, rest);
+	let { matched, positions } = flatInfo;
+	const newSelector = flatInfo.optimizedSelector;
+	if (Array.isArray($and)) {
+		const $andNew = [];
+		for (const sel of $and) {
+			const { matched: selMatched, positions: selPositions, optimizedSelector } = getIndexInfo(indexProviders, sel);
+			if (selMatched) {
+				positions = matched ? require_intersection.default(positions, selPositions) : selPositions;
+				matched = true;
+				if (Object.keys(optimizedSelector).length > 0) $andNew.push(optimizedSelector);
+			} else $andNew.push(sel);
+		}
+		if ($andNew.length > 0) newSelector.$and = $andNew;
+	}
+	if (Array.isArray($or)) {
+		const $orNew = [];
+		const matchedBefore = matched;
+		const positionsBefore = positions;
+		let hasNonIndexField = false;
+		for (const sel of $or) {
+			const { matched: selMatched, positions: selPositions, optimizedSelector } = getIndexInfo(indexProviders, sel);
+			if (selMatched) {
+				positions = [...new Set([...positions, ...selPositions])];
+				matched = true;
+				if (Object.keys(optimizedSelector).length > 0) $orNew.push(optimizedSelector);
+			} else {
+				$orNew.push(sel);
+				hasNonIndexField = true;
+			}
+		}
+		if ($orNew.length > 0) newSelector.$or = $orNew;
+		if (hasNonIndexField) {
+			newSelector.$or = $or;
+			matched = matchedBefore;
+			positions = positionsBefore;
+		}
+	}
+	return {
+		matched,
+		positions: positions || [],
+		optimizedSelector: newSelector
+	};
+}
+//#endregion
+exports.default = getIndexInfo;

package/dist/index18.mjs

@@ -1,8 +1,98 @@
-import { Query } from "mingo";
-function match(item, selector) {
-  const query = new Query(selector);
-  return query.test(item);
+import intersection from "./index17.mjs";
+//#region src/Collection/getIndexInfo.ts
+/**
+* Retrieves merged index information for a given flat selector by querying multiple
+* index providers. Combines results from all index providers to determine matched positions
+* and an optimized selector.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param indexProviders - An array of index providers to query.
+* @param selector - The flat selector used to filter items.
+* @returns An object containing:
+*   - `matched`: A boolean indicating if the selector matched any items.
+*   - `positions`: An array of matched item positions.
+*   - `optimizedSelector`: A flat selector optimized based on the index results.
+*/
+function getMergedIndexInfo(indexProviders, selector) {
+	return indexProviders.reduce((memo, indexProvider) => {
+		const info = indexProvider.query(selector);
+		if (!info.matched) return memo;
+		const optimizedSelector = info.keepSelector ? memo.optimizedSelector : Object.fromEntries(Object.entries(memo.optimizedSelector).filter(([key]) => !info.fields.includes(key)));
+		return {
+			matched: true,
+			positions: [...new Set(memo.matched ? intersection(memo.positions, info.positions) : info.positions)],
+			optimizedSelector
+		};
+	}, {
+		matched: false,
+		positions: [],
+		optimizedSelector: { ...selector }
+	});
 }
-export {
-  match as default
-};
+/**
+* Retrieves index information for a given complex selector by querying multiple
+* index providers. Handles nested `$and` and `$or` conditions in the selector and
+* optimizes the selector to minimize processing overhead.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param indexProviders - An array of index providers to query.
+* @param selector - The complex selector used to filter items.
+* @returns An object containing:
+*   - `matched`: A boolean indicating if the selector matched any items.
+*   - `positions`: An array of matched item positions.
+*   - `optimizedSelector`: A selector optimized based on the index results, with unused
+*     conditions removed.
+*/
+function getIndexInfo(indexProviders, selector) {
+	if (selector == null || Object.keys(selector).length <= 0) return {
+		matched: false,
+		positions: [],
+		optimizedSelector: selector
+	};
+	const { $and, $or, ...rest } = selector;
+	const flatInfo = getMergedIndexInfo(indexProviders, rest);
+	let { matched, positions } = flatInfo;
+	const newSelector = flatInfo.optimizedSelector;
+	if (Array.isArray($and)) {
+		const $andNew = [];
+		for (const sel of $and) {
+			const { matched: selMatched, positions: selPositions, optimizedSelector } = getIndexInfo(indexProviders, sel);
+			if (selMatched) {
+				positions = matched ? intersection(positions, selPositions) : selPositions;
+				matched = true;
+				if (Object.keys(optimizedSelector).length > 0) $andNew.push(optimizedSelector);
+			} else $andNew.push(sel);
+		}
+		if ($andNew.length > 0) newSelector.$and = $andNew;
+	}
+	if (Array.isArray($or)) {
+		const $orNew = [];
+		const matchedBefore = matched;
+		const positionsBefore = positions;
+		let hasNonIndexField = false;
+		for (const sel of $or) {
+			const { matched: selMatched, positions: selPositions, optimizedSelector } = getIndexInfo(indexProviders, sel);
+			if (selMatched) {
+				positions = [...new Set([...positions, ...selPositions])];
+				matched = true;
+				if (Object.keys(optimizedSelector).length > 0) $orNew.push(optimizedSelector);
+			} else {
+				$orNew.push(sel);
+				hasNonIndexField = true;
+			}
+		}
+		if ($orNew.length > 0) newSelector.$or = $orNew;
+		if (hasNonIndexField) {
+			newSelector.$or = $or;
+			matched = matchedBefore;
+			positions = positionsBefore;
+		}
+	}
+	return {
+		matched,
+		positions: positions || [],
+		optimizedSelector: newSelector
+	};
+}
+//#endregion
+export { getIndexInfo as default };

package/dist/index19.cjs.js

@@ -0,0 +1,11 @@
+//#region src/createIndexProvider.ts
+/**
+* Creates an IndexProvider based on the given definition.
+* @param definition - The definition of the IndexProvider.
+* @returns The created IndexProvider.
+*/
+function createIndexProvider(definition) {
+	return definition;
+}
+//#endregion
+exports.default = createIndexProvider;

package/dist/index19.mjs

@@ -1,42 +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;
+//#region src/createIndexProvider.ts
+/**
+* Creates an IndexProvider based on the given definition.
+* @param definition - The definition of the IndexProvider.
+* @returns The created IndexProvider.
+*/
+function createIndexProvider(definition) {
+	return definition;
 }
-function deepClone(object) {
-  if (typeof structuredClone === "function")
-    return structuredClone(object);
-  return clone(object);
-}
-export {
-  clone,
-  deepClone as default
-};
+//#endregion
+export { createIndexProvider as default };

package/dist/index2.cjs.js

@@ -0,0 +1,23 @@
+//#region src/utils/get.ts
+/**
+* Retrieves the value at a specified path within an object.
+* Supports dot and bracket notation for navigating nested properties.
+* @template T - The type of the object to retrieve the value from.
+* @param value - The object to navigate.
+* @param path - The path (dot or bracket notation) to the desired value.
+* @returns The value at the specified path, or `undefined` if the path does not exist.
+*/
+function get(value, path) {
+	const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
+	if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) return;
+	const segments = normalized.split(".");
+	let current = value;
+	for (const key of segments) {
+		if (current == null) return;
+		current = current[key];
+	}
+	if (current === void 0) return;
+	return current;
+}
+//#endregion
+exports.default = get;