@signaldb/core 1.7.2 → 1.8.1

package/dist/index27.mjs

@@ -1,8 +1,154 @@
-function intersection(...arrays) {
-  if (arrays.length === 0)
-    return [];
-  return [...new Set(arrays.reduce((a, b) => a.filter((c) => b.includes(c))))];
-}
-export {
-  intersection as default
+import createSignal from "./index16.mjs";
+import ReplicatedCollection from "./index26.mjs";
+//#region src/AutoFetchCollection.ts
+/**
+* A special collection that automatically fetches items when they are needed.
+*/
+var AutoFetchCollection = class 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) 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");
+			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) this.fetchSelector(selector);
+	}
+	handleObserverDisposal(selector) {
+		const activeObservers = (this.activeObservers.get(this.getKeyForSelector(selector))?.count ?? 0) - 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");
+			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) {
+		this.ensureSignal(selector).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;
+		return this.ensureSignal(selector).get() || isPushing;
+	}
 };
+//#endregion
+export { AutoFetchCollection as default };

package/dist/index28.cjs.js

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

package/dist/index28.mjs

@@ -1,30 +1,11 @@
-import isFieldExpression from "./index29.mjs";
-import serializeValue from "./index20.mjs";
-function getMatchingKeys(field, selector) {
-  const result = { include: null, exclude: null };
-  const fieldSelector = selector[field];
-  if (fieldSelector instanceof RegExp)
-    return result;
-  if (fieldSelector == null)
-    return result;
-  if (isFieldExpression(fieldSelector)) {
-    if (fieldSelector.$ne != null) {
-      result.exclude = [serializeValue(fieldSelector.$ne)];
-      return result;
-    }
-    if (Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0) {
-      result.include = fieldSelector.$in.map(serializeValue);
-      return result;
-    }
-    if (Array.isArray(fieldSelector.$nin) && fieldSelector.$nin.length > 0) {
-      result.exclude = fieldSelector.$nin.map(serializeValue);
-      return result;
-    }
-    return { include: null, exclude: null };
-  }
-  result.include = [serializeValue(fieldSelector)];
-  return result;
+//#region src/createMemoryAdapter.ts
+/**
+* Creates an MemoryAdapter based on the given definition.
+* @param definition - The definition of the MemoryAdapter.
+* @returns The created MemoryAdapter.
+*/
+function createMemoryAdapter(definition) {
+	return definition;
 }
-export {
-  getMatchingKeys as default
-};
+//#endregion
+export { createMemoryAdapter as default };

package/dist/index29.cjs.js

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

package/dist/index29.mjs

@@ -1,43 +1,11 @@
-const expressionKeys = /* @__PURE__ */ new Set([
-  "$eq",
-  "$gt",
-  "$gte",
-  "$lt",
-  "$lte",
-  "$in",
-  "$nin",
-  "$ne",
-  "$exists",
-  "$not",
-  "$expr",
-  "$jsonSchema",
-  "$mod",
-  "$regex",
-  "$options",
-  "$text",
-  "$where",
-  "$all",
-  "$elemMatch",
-  "$size",
-  "$bitsAllClear",
-  "$bitsAllSet",
-  "$bitsAnyClear",
-  "$bitsAnySet"
-]);
-function isFieldExpression(expression) {
-  if (typeof expression !== "object" || expression == null) {
-    return false;
-  }
-  const keys = Object.keys(expression);
-  if (keys.length === 0) {
-    return false;
-  }
-  const hasInvalidKeys = keys.some((key) => !expressionKeys.has(key));
-  if (hasInvalidKeys)
-    return false;
-  const hasValidKeys = keys.every((key) => expressionKeys.has(key));
-  return hasValidKeys;
+//#region src/createReactivityAdapter.ts
+/**
+* Creates an ReactivityAdapter based on the given definition.
+* @param definition - The definition of the ReactivityAdapter.
+* @returns The created ReactivityAdapter.
+*/
+function createReactivityAdapter(definition) {
+	return definition;
 }
-export {
-  isFieldExpression as default
-};
+//#endregion
+export { createReactivityAdapter as default };

package/dist/index3.cjs.js

@@ -0,0 +1,19 @@
+const require_get = require("./index2.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;