@signaldb/core 2.0.0-beta.6 → 2.0.0-beta.8

package/dist/index20.mjs

@@ -1,42 +1,37 @@
-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/utils/set.ts
+/**
+* Sets a value at a specified path within an object. Creates nested structures
+* (arrays or objects) as needed to set the value at the correct location. Supports
+* deleting the key if the value is `undefined` and the `deleteIfUndefined` flag is set to `true`.
+* @template T - The type of the object to modify.
+* @template K - The type of the value to set.
+* @param object - The object to modify. The object is mutated directly.
+* @param path - The path (dot or bracket notation) where the value should be set.
+* @param value - The value to set at the specified path.
+* @param deleteIfUndefined - A boolean indicating whether to delete the key if the value is `undefined` (default: `false`).
+* @returns The modified object.
+*/
+function set(object, path, value, deleteIfUndefined = false) {
+	if (object == null) return object;
+	const segments = path.split(/[.[\]]/g);
+	if (segments[0] === "") segments.shift();
+	if (segments.at(-1) === "") segments.pop();
+	const apply = (node) => {
+		if (segments.length > 1) {
+			const key = segments.shift();
+			const nextIsNumber = !Number.isNaN(Number.parseInt(segments[0], 10));
+			if (node[key] === void 0) node[key] = nextIsNumber ? [] : {};
+			apply(node[key]);
+		} else {
+			if (deleteIfUndefined && value === void 0) {
+				delete node[segments[0]];
+				return;
+			}
+			node[segments[0]] = value;
+		}
+	};
+	apply(object);
+	return object;
 }
-function deepClone(object) {
-  if (typeof structuredClone === "function")
-    return structuredClone(object);
-  return clone(object);
-}
-export {
-  clone,
-  deepClone as default
-};
+//#endregion
+export { set as default };

package/dist/index21.cjs.js

@@ -0,0 +1,35 @@
+const require_get = require("./index10.cjs.js");
+const require_set = require("./index20.cjs.js");
+//#region src/utils/project.ts
+/**
+* Projects the fields of an object based on a specified fields configuration.
+* Supports inclusion (`1`) and exclusion (`0`) of specific fields. Creates a new object
+* with the desired fields included or excluded, based on the configuration.
+* @template T - The type of the object being projected.
+* @param item - The original object to project fields from.
+* @param fields - An object defining the fields to include (`1`) or exclude (`0`).
+*   - Keys are the field names, and values are either `1` (include) or `0` (exclude).
+* @returns A new object with the specified fields included or excluded.
+*   - If all fields are set to `0`, the excluded fields are removed from the result.
+*   - If fields are set to `1`, only the included fields are retained.
+*/
+function project(item, fields) {
+	if (Object.values(fields).every((value) => value === 0)) {
+		const result = { ...item };
+		Object.keys(fields).forEach((key) => {
+			if (require_get.default(item, key) === void 0) return;
+			require_set.default(result, key, void 0, true);
+		});
+		return result;
+	}
+	const result = {};
+	Object.entries(fields).forEach(([key, value]) => {
+		const fieldValue = require_get.default(item, key);
+		if (fieldValue === void 0) return;
+		if (fieldValue == null && value !== 1) return;
+		require_set.default(result, key, value === 1 ? fieldValue : void 0);
+	});
+	return result;
+}
+//#endregion
+exports.default = project;

package/dist/index21.mjs

@@ -1,17 +1,35 @@
-function isEmptyOptions(options) {
-  if (options == null)
-    return true;
-  if (typeof options !== "object")
-    return false;
-  if (Array.isArray(options))
-    return false;
-  return Object.keys(options).length === 0;
+import get from "./index10.mjs";
+import set from "./index20.mjs";
+//#region src/utils/project.ts
+/**
+* Projects the fields of an object based on a specified fields configuration.
+* Supports inclusion (`1`) and exclusion (`0`) of specific fields. Creates a new object
+* with the desired fields included or excluded, based on the configuration.
+* @template T - The type of the object being projected.
+* @param item - The original object to project fields from.
+* @param fields - An object defining the fields to include (`1`) or exclude (`0`).
+*   - Keys are the field names, and values are either `1` (include) or `0` (exclude).
+* @returns A new object with the specified fields included or excluded.
+*   - If all fields are set to `0`, the excluded fields are removed from the result.
+*   - If fields are set to `1`, only the included fields are retained.
+*/
+function project(item, fields) {
+	if (Object.values(fields).every((value) => value === 0)) {
+		const result = { ...item };
+		Object.keys(fields).forEach((key) => {
+			if (get(item, key) === void 0) return;
+			set(result, key, void 0, true);
+		});
+		return result;
+	}
+	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;
 }
-function queryId(selector, options) {
-  const selectorId = JSON.stringify(selector);
-  const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
-  return `${selectorId}:${optionsId}`;
-}
-export {
-  queryId as default
-};
+//#endregion
+export { project as default };

package/dist/index22.cjs.js

@@ -0,0 +1,25 @@
+//#region src/utils/queryId.ts
+/**
+* Returns true when `options` is effectively "empty" for the purpose of queryId generation.
+* Treats `undefined`/`null` as empty, and only considers plain objects with zero own enumerable keys as empty.
+* Arrays and non-object values are not considered empty.
+* @param options - Query options to test.
+* @returns `true` if `options` is `null`/`undefined` or a plain object with no own keys; otherwise `false`.
+*/
+function isEmptyOptions(options) {
+	if (options == null) return true;
+	if (typeof options !== "object") return false;
+	if (Array.isArray(options)) return false;
+	return Object.keys(options).length === 0;
+}
+/**
+* Generates a unique identifier for a query based on its selector and options.
+* @param selector - The selector object.
+* @param options - The query options object (optional).
+* @returns A unique identifier string for the query.
+*/
+function queryId(selector, options) {
+	return `${JSON.stringify(selector)}:${isEmptyOptions(options) ? -1 : JSON.stringify(options)}`;
+}
+//#endregion
+exports.default = queryId;

package/dist/index22.mjs

@@ -1,105 +1,25 @@
-import createIndexProvider from "./index34.mjs";
-import get from "./index10.mjs";
-import getMatchingKeys from "./index27.mjs";
-import serializeValue from "./index11.mjs";
-function createIndex(field) {
-  const index = /* @__PURE__ */ new Map();
-  const ensureSet = (key) => {
-    let set = index.get(key);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      index.set(key, set);
-    }
-    return set;
-  };
-  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 includedIds = [];
-      if (keys.include == null) {
-        for (const set of index.values()) {
-          for (const pos of set) {
-            includedIds.push(pos);
-          }
-        }
-      } else {
-        for (const key of keys.include) {
-          const posSet = index.get(key);
-          if (posSet) {
-            for (const pos of posSet) {
-              includedIds.push(pos);
-            }
-          }
-        }
-      }
-      if (keys.exclude != null) {
-        const excludeIds = /* @__PURE__ */ new Set();
-        for (const key of keys.exclude) {
-          const posSet = index.get(key);
-          if (posSet) {
-            for (const pos of posSet) {
-              excludeIds.add(pos);
-            }
-          }
-        }
-        includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
-      }
-      return {
-        matched: true,
-        ids: includedIds,
-        fields: [field],
-        keepSelector: filteresForNull
-      };
-    },
-    rebuild(items) {
-      index.clear();
-      items.forEach((item) => {
-        const value = serializeValue(get(item, field));
-        ensureSet(value).add(item.id);
-      });
-    },
-    // NEW: delta methods
-    insert(items) {
-      for (const item of items) {
-        const value = serializeValue(get(item, field));
-        ensureSet(value).add(item.id);
-      }
-    },
-    remove(items) {
-      for (const item of items) {
-        const value = serializeValue(get(item, field));
-        const set = index.get(value);
-        if (!set)
-          continue;
-        set.delete(item.id);
-        if (set.size === 0)
-          index.delete(value);
-      }
-    },
-    update(pairs) {
-      for (const { oldItem, newItem } of pairs) {
-        const oldValue = serializeValue(get(oldItem, field));
-        const newValue = serializeValue(get(newItem, field));
-        if (oldValue === newValue)
-          continue;
-        const oldSet = index.get(oldValue);
-        if (oldSet) {
-          oldSet.delete(oldItem.id);
-          if (oldSet.size === 0)
-            index.delete(oldValue);
-        }
-        ensureSet(newValue).add(newItem.id);
-      }
-    }
-  });
+//#region src/utils/queryId.ts
+/**
+* Returns true when `options` is effectively "empty" for the purpose of queryId generation.
+* Treats `undefined`/`null` as empty, and only considers plain objects with zero own enumerable keys as empty.
+* Arrays and non-object values are not considered empty.
+* @param options - Query options to test.
+* @returns `true` if `options` is `null`/`undefined` or a plain object with no own keys; otherwise `false`.
+*/
+function isEmptyOptions(options) {
+	if (options == null) return true;
+	if (typeof options !== "object") return false;
+	if (Array.isArray(options)) return false;
+	return Object.keys(options).length === 0;
 }
-export {
-  createIndex as default
-};
+/**
+* Generates a unique identifier for a query based on its selector and options.
+* @param selector - The selector object.
+* @param options - The query options object (optional).
+* @returns A unique identifier string for the query.
+*/
+function queryId(selector, options) {
+	return `${JSON.stringify(selector)}:${isEmptyOptions(options) ? -1 : JSON.stringify(options)}`;
+}
+//#endregion
+export { queryId as default };

package/dist/index23.cjs.js

@@ -0,0 +1,19 @@
+const require_get = require("./index10.cjs.js");
+let fast_sort = require("fast-sort");
+//#region src/utils/sortItems.ts
+/**
+* Sorts an array of items based on multiple fields and their specified sort order.
+* Uses the `fast-sort` library for efficient sorting.
+* @template T - The type of the items in the array.
+* @param items - The array of items to be sorted.
+* @param sortFields - An object defining the sort order for each field.
+*   - Keys are the field names, and values are either `1` (ascending) or `-1` (descending).
+* @returns A new array of items sorted based on the specified fields and their order.
+*/
+function sortItems(items, sortFields) {
+	return (0, fast_sort.sort)(items).by(Object.entries(sortFields).map(([key, value]) => {
+		return { [value === 1 ? "asc" : "desc"]: (i) => require_get.default(i, key) };
+	}));
+}
+//#endregion
+exports.default = sortItems;

package/dist/index23.mjs

@@ -1,129 +1,19 @@
-import intersection from "./index31.mjs";
-function getMergedIndexInfo(queryFunctions, selector) {
-  return queryFunctions.reduce((memoOrPromise, queryFunction) => {
-    const resultOrPromise = queryFunction(selector);
-    const processResult = (memo2, result) => {
-      if (!result.matched)
-        return memo2;
-      const optimizedSelector = result.keepSelector ? memo2.optimizedSelector : Object.fromEntries(Object.entries(memo2.optimizedSelector).filter(([key]) => !result.fields.includes(key)));
-      return {
-        matched: true,
-        ids: [...new Set(memo2.matched ? intersection(memo2.ids, result.ids) : result.ids)],
-        optimizedSelector
-      };
-    };
-    if (resultOrPromise instanceof Promise) {
-      return resultOrPromise.then(async (result) => {
-        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
-        return processResult(memo2, result);
-      });
-    }
-    const memo = memoOrPromise;
-    if (memo instanceof Promise)
-      throw new Error("Mixing async and sync index providers is not supported");
-    return processResult(memo, resultOrPromise);
-  }, {
-    matched: false,
-    ids: [],
-    optimizedSelector: { ...selector }
-  });
+import get from "./index10.mjs";
+import { sort } from "fast-sort";
+//#region src/utils/sortItems.ts
+/**
+* Sorts an array of items based on multiple fields and their specified sort order.
+* Uses the `fast-sort` library for efficient sorting.
+* @template T - The type of the items in the array.
+* @param items - The array of items to be sorted.
+* @param sortFields - An object defining the sort order for each field.
+*   - Keys are the field names, and values are either `1` (ascending) or `-1` (descending).
+* @returns A new array of items sorted based on the specified fields and their order.
+*/
+function sortItems(items, sortFields) {
+	return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
+		return { [value === 1 ? "asc" : "desc"]: (i) => get(i, key) };
+	}));
 }
-function optimizeLogicGate(queryFunctions, logicGate, idsCallback) {
-  return logicGate.reduce((memoOrPromise, sel) => {
-    const getSelector = (indexInfo) => {
-      const { matched: selMatched, ids: selIds, optimizedSelector: optimizedSelector2 } = indexInfo;
-      if (selMatched) {
-        idsCallback(true, selIds);
-        if (Object.keys(optimizedSelector2).length > 0) {
-          return optimizedSelector2;
-        }
-      } else {
-        idsCallback(false, []);
-        return sel;
-      }
-    };
-    const indexInfoOrPromise = getIndexInfo(queryFunctions, sel);
-    if (indexInfoOrPromise instanceof Promise) {
-      return indexInfoOrPromise.then(async (indexInfo) => {
-        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
-        const optimizedSelector2 = getSelector(indexInfo);
-        if (optimizedSelector2)
-          memo2.push(optimizedSelector2);
-        return memo2;
-      });
-    }
-    const memo = memoOrPromise;
-    if (memo instanceof Promise)
-      throw new Error("Mixing async and sync index providers is not supported");
-    const optimizedSelector = getSelector(indexInfoOrPromise);
-    if (optimizedSelector)
-      memo.push(optimizedSelector);
-    return memo;
-  }, []);
-}
-function getIndexInfo(queryFunctions, selector) {
-  if (selector == null || Object.keys(selector).length <= 0) {
-    return {
-      matched: false,
-      ids: [],
-      optimizedSelector: selector
-    };
-  }
-  const { $and, $or, ...rest } = selector;
-  const flatInfoOrPromise = getMergedIndexInfo(queryFunctions, rest);
-  const processFlatInfo = (flatInfo) => {
-    let { matched, ids } = flatInfo;
-    const newSelector = flatInfo.optimizedSelector;
-    const $andNewOrPromise = Array.isArray($and) ? optimizeLogicGate(queryFunctions, $and, (match, selIds) => {
-      if (!match)
-        return;
-      ids = matched ? intersection(ids, selIds) : selIds;
-      matched = true;
-    }) : void 0;
-    const process$and = ($andNew) => {
-      if ($andNew && $andNew.length > 0)
-        newSelector.$and = $andNew;
-      let hasNonIndexField = false;
-      const matchedBefore = matched;
-      const idsBefore = ids;
-      const process$or = ($orNew) => {
-        if ($orNew && $orNew.length > 0)
-          newSelector.$or = $orNew;
-        if (hasNonIndexField) {
-          newSelector.$or = $or;
-          matched = matchedBefore;
-          ids = idsBefore;
-        }
-        return {
-          matched,
-          ids: ids || [],
-          optimizedSelector: newSelector
-        };
-      };
-      const $orNewOrPromise = Array.isArray($or) ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
-        if (match) {
-          ids = [.../* @__PURE__ */ new Set([...ids, ...selIds])];
-          matched = true;
-        } else {
-          hasNonIndexField = true;
-        }
-      }) : void 0;
-      if ($orNewOrPromise instanceof Promise) {
-        return $orNewOrPromise.then(($orNew) => process$or($orNew));
-      }
-      return process$or($orNewOrPromise);
-    };
-    if ($andNewOrPromise instanceof Promise) {
-      return $andNewOrPromise.then(($andNew) => process$and($andNew));
-    }
-    return process$and($andNewOrPromise);
-  };
-  if (flatInfoOrPromise instanceof Promise) {
-    return flatInfoOrPromise.then(processFlatInfo);
-  }
-  return processFlatInfo(flatInfoOrPromise);
-}
-export {
-  getIndexInfo as default,
-  getMergedIndexInfo
-};
+//#endregion
+export { sortItems as default };