@signaldb/core 1.7.2 → 1.8.1

package/dist/index4.cjs.js

@@ -0,0 +1,37 @@
+//#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;
+}
+//#endregion
+exports.default = set;

package/dist/index4.mjs

@@ -1,168 +1,37 @@
-import ReplicatedCollection from "./index23.mjs";
-import createSignal from "./index21.mjs";
-class AutoFetchCollection extends ReplicatedCollection {
-  activeObservers = /* @__PURE__ */ new Map();
-  observerTimeouts = /* @__PURE__ */ new Map();
-  purgeDelay;
-  idQueryCache = /* @__PURE__ */ new Map();
-  itemsCache = /* @__PURE__ */ new Map();
-  fetchQueryItems;
-  triggerReload = null;
-  reactivityAdapter = null;
-  loadingSignals = /* @__PURE__ */ new Map();
-  isFetchingSignal;
-  mergeItems;
-  /**
-   * @param options {Object} - Options for the collection.
-   * @param options.fetchQueryItems {Function} - A function that fetches items from the server. It takes the selector as an argument and returns a promise that resolves to an object with an `items` property.
-   * @param options.purgeDelay {Number} - The delay in milliseconds before purging an item from the cache.
-   */
-  constructor(options) {
-    let triggerRemoteChange;
-    super({
-      ...options,
-      pull: () => Promise.resolve({
-        items: [...this.itemsCache.values()].reduce((memo, items) => {
-          const newItems = [...memo];
-          items.forEach((item) => {
-            const index = newItems.findIndex((i) => i.id === item.id);
-            if (index === -1) {
-              newItems.push(item);
-              return;
-            }
-            newItems[index] = this.mergeItems(newItems[index], item);
-          });
-          return newItems;
-        }, [])
-      }),
-      registerRemoteChange: async (onChange) => {
-        triggerRemoteChange = onChange;
-      }
-    });
-    this.mergeItems = options.mergeItems ?? ((itemA, itemB) => ({ ...itemA, ...itemB }));
-    this.purgeDelay = options.purgeDelay ?? 1e4;
-    this.isFetchingSignal = createSignal(options.reactivity, false);
-    if (!triggerRemoteChange)
-      throw new Error("No triggerRemoteChange method found. Looks like your persistence adapter was not registered");
-    this.triggerReload = triggerRemoteChange;
-    this.reactivityAdapter = options.reactivity ?? null;
-    this.fetchQueryItems = options.fetchQueryItems;
-    this.on("observer.created", (selector) => this.handleObserverCreation(selector ?? {}));
-    this.on("observer.disposed", (selector) => setTimeout(() => this.handleObserverDisposal(selector ?? {}), 100));
-    if (options.registerRemoteChange) {
-      void options.registerRemoteChange(() => this.forceRefetch());
-    }
-  }
-  /**
-   * Registers a query manually that items should be fetched for it
-   * @param selector {Object} Selector of the query
-   */
-  registerQuery(selector) {
-    this.handleObserverCreation(selector);
-  }
-  /**
-   * Unregisters a query manually that items are not fetched anymore for it
-   * @param selector {Object} Selector of the query
-   */
-  unregisterQuery(selector) {
-    this.handleObserverDisposal(selector);
-  }
-  getKeyForSelector(selector) {
-    return JSON.stringify(selector);
-  }
-  async forceRefetch() {
-    return Promise.all([...this.activeObservers.values()].map(({ selector }) => this.fetchSelector(selector))).then(() => {
-    });
-  }
-  fetchSelector(selector) {
-    this.isFetchingSignal.set(true);
-    return this.fetchQueryItems(selector).then((response) => {
-      if (!response.items)
-        throw new Error("AutoFetchCollection currently only works with a full item response");
-      this.itemsCache.set(this.getKeyForSelector(selector), response.items);
-      response.items.forEach((item) => {
-        const queries = this.idQueryCache.get(item.id) ?? [];
-        queries.push(selector);
-        this.idQueryCache.set(item.id, queries);
-      });
-      this.setLoading(selector, true);
-      this.once("persistence.received", () => {
-        this.setLoading(selector, false);
-      });
-      if (!this.triggerReload)
-        throw new Error("No triggerReload method found. Looks like your persistence adapter was not registered");
-      void this.triggerReload();
-    }).catch((error) => {
-      this.emit("persistence.error", error);
-    }).finally(() => {
-      this.isFetchingSignal.set(false);
-    });
-  }
-  handleObserverCreation(selector) {
-    const activeObservers = this.activeObservers.get(this.getKeyForSelector(selector))?.count ?? 0;
-    this.activeObservers.set(this.getKeyForSelector(selector), {
-      selector,
-      count: activeObservers + 1
-    });
-    const timeout = this.observerTimeouts.get(this.getKeyForSelector(selector));
-    if (timeout)
-      clearTimeout(timeout);
-    if (activeObservers === 0)
-      void this.fetchSelector(selector);
-  }
-  handleObserverDisposal(selector) {
-    const currentObservers = this.activeObservers.get(this.getKeyForSelector(selector))?.count ?? 0;
-    const activeObservers = currentObservers - 1;
-    if (activeObservers > 0) {
-      this.activeObservers.set(this.getKeyForSelector(selector), {
-        selector,
-        count: activeObservers
-      });
-      return;
-    }
-    const timeout = this.observerTimeouts.get(this.getKeyForSelector(selector));
-    if (timeout)
-      clearTimeout(timeout);
-    const removeObserver = () => {
-      this.activeObservers.delete(this.getKeyForSelector(selector));
-      this.itemsCache.delete(this.getKeyForSelector(selector));
-      if (!this.triggerReload)
-        throw new Error("No triggerReload method found. Looks like your persistence adapter was not registered");
-      void this.triggerReload();
-    };
-    if (this.purgeDelay === 0) {
-      removeObserver();
-      return;
-    }
-    this.observerTimeouts.set(this.getKeyForSelector(selector), setTimeout(removeObserver, this.purgeDelay));
-  }
-  ensureSignal(selector) {
-    if (!this.reactivityAdapter)
-      throw new Error("No reactivity adapter found");
-    if (!this.loadingSignals.has(this.getKeyForSelector(selector))) {
-      this.loadingSignals.set(this.getKeyForSelector(selector), createSignal(this.reactivityAdapter, false));
-    }
-    return this.loadingSignals.get(this.getKeyForSelector(selector));
-  }
-  setLoading(selector, value) {
-    const signal = this.ensureSignal(selector);
-    signal.set(value);
-  }
-  /**
-   * Indicates wether a query is currently been loaded
-   * ⚡️ this function is reactive!
-   * @param selector {Object} Selector of the query
-   * @returns The loading state
-   */
-  isLoading(selector) {
-    const isPushing = this.isPushing();
-    if (!selector) {
-      return this.isFetchingSignal.get() || isPushing;
-    }
-    const signal = this.ensureSignal(selector);
-    return signal.get() || isPushing;
-  }
+//#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;
 }
-export {
-  AutoFetchCollection as default
-};
+//#endregion
+export { set as default };

package/dist/index5.cjs.js

@@ -0,0 +1,35 @@
+const require_get = require("./index2.cjs.js");
+const require_set = require("./index4.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/index5.mjs

@@ -1,68 +1,35 @@
-import createPersistenceAdapter from "./index8.mjs";
-function createTemporaryFallbackExecutor(firstResolvingPromiseFunction, secondResolvingPromiseFunction, options) {
-  const cacheTimeout = options?.cacheTimeout;
-  let isResolved = false;
-  let resolvedValue = null;
-  let timeout = null;
-  let secondaryPromise = null;
-  return (...args) => {
-    if (secondaryPromise == null) {
-      if (timeout) {
-        clearTimeout(timeout);
-        timeout = null;
-      }
-      secondaryPromise = secondResolvingPromiseFunction(...args).then((result) => {
-        {
-          timeout = setTimeout(() => {
-            isResolved = false;
-            resolvedValue = null;
-            secondaryPromise = null;
-          }, cacheTimeout);
-        }
-        isResolved = true;
-        resolvedValue = result;
-        if (options?.onResolve)
-          options.onResolve(resolvedValue);
-        return result;
-      });
-    } else if (isResolved) {
-      return secondaryPromise;
-    }
-    return firstResolvingPromiseFunction(...args);
-  };
+import get from "./index2.mjs";
+import set from "./index4.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 combinePersistenceAdapters(slowAdapter, fastAdapter) {
-  let handleChange = null;
-  const readExecutor = createTemporaryFallbackExecutor(() => fastAdapter.load(), () => slowAdapter.load(), {
-    cacheTimeout: 100,
-    onResolve: (result) => {
-      if (handleChange)
-        void handleChange();
-      void fastAdapter.save(result.items || [], {
-        added: result.changes?.added || [],
-        modified: result.changes?.modified || [],
-        removed: result.changes?.removed || []
-      });
-    }
-  });
-  return createPersistenceAdapter({
-    async register(onChange) {
-      handleChange = onChange;
-      await Promise.all([slowAdapter.register(onChange), fastAdapter.register(onChange)]);
-    },
-    async load() {
-      const promise = readExecutor();
-      return promise;
-    },
-    async save(items, changes) {
-      await Promise.all([
-        fastAdapter.save(items, changes),
-        slowAdapter.save(items, changes)
-      ]);
-    }
-  });
-}
-export {
-  createTemporaryFallbackExecutor,
-  combinePersistenceAdapters as default
-};
+//#endregion
+export { project as default };

package/dist/index6.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/index6.mjs

@@ -1,6 +1,47 @@
-function createIndexProvider(definition) {
-  return definition;
+//#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 {
-  createIndexProvider 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/index7.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;

package/dist/index7.mjs

@@ -1,6 +1,33 @@
-function createMemoryAdapter(definition) {
-  return definition;
+//#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;
 }
-export {
-  createMemoryAdapter as default
-};
+//#endregion
+export { isEqual as default };

package/dist/index8.cjs.js

@@ -0,0 +1,19 @@
+//#region src/utils/uniqueBy.ts
+/**
+* Filters an array to ensure unique values based on a specified key or transformation function.
+* @template T - The type of the elements in the array.
+* @param array - The array to filter for unique values.
+* @param fn - A key or transformation function to determine uniqueness.
+*   - If a key is provided, it will use the corresponding property of each element for uniqueness.
+*   - If a function is provided, it will use the return value of the function applied to each element for uniqueness.
+* @returns A new array containing only unique elements based on the specified key or transformation.
+*/
+function uniqueBy(array, fn) {
+	const set = /* @__PURE__ */ new Set();
+	return array.filter((element) => {
+		const value = typeof fn === "function" ? fn(element) : element[fn];
+		return !set.has(value) && set.add(value);
+	});
+}
+//#endregion
+exports.default = uniqueBy;

package/dist/index8.mjs

@@ -1,6 +1,19 @@
-function createPersistenceAdapter(definition) {
-  return definition;
+//#region src/utils/uniqueBy.ts
+/**
+* Filters an array to ensure unique values based on a specified key or transformation function.
+* @template T - The type of the elements in the array.
+* @param array - The array to filter for unique values.
+* @param fn - A key or transformation function to determine uniqueness.
+*   - If a key is provided, it will use the corresponding property of each element for uniqueness.
+*   - If a function is provided, it will use the return value of the function applied to each element for uniqueness.
+* @returns A new array containing only unique elements based on the specified key or transformation.
+*/
+function uniqueBy(array, fn) {
+	const set = /* @__PURE__ */ new Set();
+	return array.filter((element) => {
+		const value = typeof fn === "function" ? fn(element) : element[fn];
+		return !set.has(value) && set.add(value);
+	});
 }
-export {
-  createPersistenceAdapter as default
-};
+//#endregion
+export { uniqueBy as default };