@signaldb/core 1.7.2 → 1.8.1

package/dist/index24.cjs.js

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

package/dist/index24.mjs

@@ -1,19 +1,11 @@
-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;
+//#region src/persistence/createPersistenceAdapter.ts
+/**
+* Creates an PersistenceAdapter based on the given definition.
+* @param definition - The definition of the PersistenceAdapter.
+* @returns The created PersistenceAdapter.
+*/
+function createPersistenceAdapter(definition) {
+	return definition;
 }
-export {
-  get as default
-};
+//#endregion
+export { createPersistenceAdapter as default };

package/dist/index25.cjs.js

@@ -0,0 +1,81 @@
+const require_createPersistenceAdapter = require("./index24.cjs.js");
+//#region src/persistence/combinePersistenceAdapters.ts
+/**
+* Creates a function that executes two asynchronous functions sequentially.
+* The first function is tried first, and if it resolves, its value is used.
+* If the first function fails or a fallback is required, the second function is executed.
+* An optional cache mechanism can store the result temporarily to improve performance.
+* @template Arguments - The argument types for the promise functions.
+* @template ReturnValue - The return value type of the promise functions.
+* @param firstResolvingPromiseFunction - The primary promise-based function to execute.
+* @param secondResolvingPromiseFunction - The secondary fallback promise-based function to execute.
+* @param [options] - Optional configuration.
+* @param [options.onResolve] - Callback executed when a promise resolves.
+* @param [options.cacheTimeout] - Time (in ms) to cache the resolved result.
+* @returns A function that executes the two promises as described.
+*/
+function createTemporaryFallbackExecutor(firstResolvingPromiseFunction, secondResolvingPromiseFunction, options) {
+	const cacheTimeout = options?.cacheTimeout ?? 0;
+	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) => {
+				if (cacheTimeout > 0) 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);
+	};
+}
+/**
+* Combines two persistence adapters (fast and slow) into a single interface.
+* The fast adapter is used for quick read and write operations, while the slow adapter
+* ensures data persistence and durability. The adapters sync automatically on read and save operations.
+* @template T - The type of the persisted data items.
+* @template I - The type of the identifier for persisted data items.
+* @param slowAdapter - The slow persistence adapter for long-term storage.
+* @param fastAdapter - The fast persistence adapter for quick access.
+* @returns A combined persistence adapter that manages synchronization between the two adapters.
+*/
+function combinePersistenceAdapters(slowAdapter, fastAdapter) {
+	let handleChange = null;
+	const readExecutor = createTemporaryFallbackExecutor(() => fastAdapter.load(), () => slowAdapter.load(), {
+		cacheTimeout: 100,
+		onResolve: (result) => {
+			if (handleChange) handleChange();
+			fastAdapter.save(result.items || [], {
+				added: result.changes?.added || [],
+				modified: result.changes?.modified || [],
+				removed: result.changes?.removed || []
+			});
+		}
+	});
+	return require_createPersistenceAdapter.default({
+		async register(onChange) {
+			handleChange = onChange;
+			await Promise.all([slowAdapter.register(onChange), fastAdapter.register(onChange)]);
+		},
+		async load() {
+			return readExecutor();
+		},
+		async save(items, changes) {
+			await Promise.all([fastAdapter.save(items, changes), slowAdapter.save(items, changes)]);
+		}
+	});
+}
+//#endregion
+exports.default = combinePersistenceAdapters;

package/dist/index25.mjs

@@ -1,30 +1,81 @@
-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;
+import createPersistenceAdapter from "./index24.mjs";
+//#region src/persistence/combinePersistenceAdapters.ts
+/**
+* Creates a function that executes two asynchronous functions sequentially.
+* The first function is tried first, and if it resolves, its value is used.
+* If the first function fails or a fallback is required, the second function is executed.
+* An optional cache mechanism can store the result temporarily to improve performance.
+* @template Arguments - The argument types for the promise functions.
+* @template ReturnValue - The return value type of the promise functions.
+* @param firstResolvingPromiseFunction - The primary promise-based function to execute.
+* @param secondResolvingPromiseFunction - The secondary fallback promise-based function to execute.
+* @param [options] - Optional configuration.
+* @param [options.onResolve] - Callback executed when a promise resolves.
+* @param [options.cacheTimeout] - Time (in ms) to cache the resolved result.
+* @returns A function that executes the two promises as described.
+*/
+function createTemporaryFallbackExecutor(firstResolvingPromiseFunction, secondResolvingPromiseFunction, options) {
+	const cacheTimeout = options?.cacheTimeout ?? 0;
+	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) => {
+				if (cacheTimeout > 0) 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);
+	};
 }
-export {
-  set as default
-};
+/**
+* Combines two persistence adapters (fast and slow) into a single interface.
+* The fast adapter is used for quick read and write operations, while the slow adapter
+* ensures data persistence and durability. The adapters sync automatically on read and save operations.
+* @template T - The type of the persisted data items.
+* @template I - The type of the identifier for persisted data items.
+* @param slowAdapter - The slow persistence adapter for long-term storage.
+* @param fastAdapter - The fast persistence adapter for quick access.
+* @returns A combined persistence adapter that manages synchronization between the two adapters.
+*/
+function combinePersistenceAdapters(slowAdapter, fastAdapter) {
+	let handleChange = null;
+	const readExecutor = createTemporaryFallbackExecutor(() => fastAdapter.load(), () => slowAdapter.load(), {
+		cacheTimeout: 100,
+		onResolve: (result) => {
+			if (handleChange) handleChange();
+			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() {
+			return readExecutor();
+		},
+		async save(items, changes) {
+			await Promise.all([fastAdapter.save(items, changes), slowAdapter.save(items, changes)]);
+		}
+	});
+}
+//#endregion
+export { combinePersistenceAdapters as default };

package/dist/index26.cjs.js

@@ -0,0 +1,98 @@
+const require_createSignal = require("./index16.cjs.js");
+const require_index = require("./index23.cjs.js");
+const require_createPersistenceAdapter = require("./index24.cjs.js");
+const require_combinePersistenceAdapters = require("./index25.cjs.js");
+//#region src/ReplicatedCollection.ts
+/**
+* Creates a persistence adapter for replicating a collection, enabling pull and push
+* operations for synchronizing with a remote source. Supports optional remote change registration.
+* @template T - The type of the items being replicated.
+* @template I - The type of the unique identifier for the items.
+* @param options - The options for configuring the replication adapter.
+* @param options.pull - A function to fetch data from the remote source.
+* @param options.push - An optional function to send changes and items to the remote source.
+* @param options.registerRemoteChange - An optional function to register a listener for remote changes.
+* @returns A persistence adapter configured for replication.
+*/
+function createReplicationAdapter(options) {
+	return require_createPersistenceAdapter.default({
+		async register(onChange) {
+			if (!options.registerRemoteChange) return;
+			await options.registerRemoteChange(onChange);
+		},
+		load: () => options.pull(),
+		save: (items, changes) => {
+			if (!options.push) throw new Error("Pushing is not configured for this collection. Try to pass a `push` function to the collection options.");
+			return options.push(changes, items);
+		}
+	});
+}
+/**
+* Extends the `Collection` class to support replication with remote sources.
+* Handles pull and push operations, remote change registration, and enhanced loading states.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @template U - The transformed item type after applying transformations (default is T).
+*/
+var ReplicatedCollection = class extends require_index.default {
+	isPullingRemoteSignal;
+	isPushingRemoteSignal;
+	/**
+	* Creates a new instance of the `ReplicatedCollection` class.
+	* Sets up the replication adapter, combining it with an optional persistence adapter, and
+	* initializes signals for tracking remote pull and push operations.
+	* @param options - The configuration options for the replicated collection.
+	* @param options.pull - A function to fetch data from the remote source.
+	* @param options.push - An optional function to send changes and items to the remote source.
+	* @param options.registerRemoteChange - An optional function to register a listener for remote changes.
+	* @param options.persistence - An optional persistence adapter to combine with replication.
+	* @param options.reactivity - A reactivity adapter for observing changes in the collection.
+	* @param options.transform - A transformation function to apply to items when retrieving them.
+	* @param options.indices - An array of index providers for optimized querying.
+	* @param options.enableDebugMode - A boolean to enable or disable debug mode.
+	*/
+	constructor(options) {
+		const replicationAdapter = createReplicationAdapter({
+			registerRemoteChange: options.registerRemoteChange,
+			pull: async () => {
+				this.isPullingRemoteSignal.set(true);
+				try {
+					return await options.pull();
+				} finally {
+					this.isPullingRemoteSignal.set(false);
+				}
+			},
+			push: options.push ? async (changes, items) => {
+				if (!options.push) throw new Error("Pushing is not configured for this collection. Try to pass a `push` function to the collection options.");
+				this.isPushingRemoteSignal.set(true);
+				try {
+					await options.push(changes, items);
+				} finally {
+					this.isPushingRemoteSignal.set(false);
+				}
+			} : void 0
+		});
+		const persistenceAdapter = options?.persistence ? require_combinePersistenceAdapters.default(replicationAdapter, options.persistence) : replicationAdapter;
+		super({
+			...options,
+			persistence: persistenceAdapter
+		});
+		this.isPullingRemoteSignal = require_createSignal.default(options.reactivity, false);
+		this.isPushingRemoteSignal = require_createSignal.default(options.reactivity, false);
+	}
+	/**
+	* Checks whether the collection is currently performing any loading operation,
+	* including pulling or pushing data from/to the remote source, or standard
+	* persistence adapter operations.
+	* ⚡️ this function is reactive!
+	* @returns A boolean indicating if the collection is currently loading or synchronizing.
+	*/
+	isLoading() {
+		const isPullingRemote = this.isPullingRemoteSignal.get();
+		const isPushingRemote = this.isPushingRemoteSignal.get();
+		const isLoading = super.isLoading();
+		return isPullingRemote || isPushingRemote || isLoading;
+	}
+};
+//#endregion
+exports.default = ReplicatedCollection;

package/dist/index26.mjs

@@ -1,10 +1,98 @@
-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);
-  });
+import createSignal from "./index16.mjs";
+import Collection from "./index23.mjs";
+import createPersistenceAdapter from "./index24.mjs";
+import combinePersistenceAdapters from "./index25.mjs";
+//#region src/ReplicatedCollection.ts
+/**
+* Creates a persistence adapter for replicating a collection, enabling pull and push
+* operations for synchronizing with a remote source. Supports optional remote change registration.
+* @template T - The type of the items being replicated.
+* @template I - The type of the unique identifier for the items.
+* @param options - The options for configuring the replication adapter.
+* @param options.pull - A function to fetch data from the remote source.
+* @param options.push - An optional function to send changes and items to the remote source.
+* @param options.registerRemoteChange - An optional function to register a listener for remote changes.
+* @returns A persistence adapter configured for replication.
+*/
+function createReplicationAdapter(options) {
+	return createPersistenceAdapter({
+		async register(onChange) {
+			if (!options.registerRemoteChange) return;
+			await options.registerRemoteChange(onChange);
+		},
+		load: () => options.pull(),
+		save: (items, changes) => {
+			if (!options.push) throw new Error("Pushing is not configured for this collection. Try to pass a `push` function to the collection options.");
+			return options.push(changes, items);
+		}
+	});
 }
-export {
-  uniqueBy as default
+/**
+* Extends the `Collection` class to support replication with remote sources.
+* Handles pull and push operations, remote change registration, and enhanced loading states.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @template U - The transformed item type after applying transformations (default is T).
+*/
+var ReplicatedCollection = class extends Collection {
+	isPullingRemoteSignal;
+	isPushingRemoteSignal;
+	/**
+	* Creates a new instance of the `ReplicatedCollection` class.
+	* Sets up the replication adapter, combining it with an optional persistence adapter, and
+	* initializes signals for tracking remote pull and push operations.
+	* @param options - The configuration options for the replicated collection.
+	* @param options.pull - A function to fetch data from the remote source.
+	* @param options.push - An optional function to send changes and items to the remote source.
+	* @param options.registerRemoteChange - An optional function to register a listener for remote changes.
+	* @param options.persistence - An optional persistence adapter to combine with replication.
+	* @param options.reactivity - A reactivity adapter for observing changes in the collection.
+	* @param options.transform - A transformation function to apply to items when retrieving them.
+	* @param options.indices - An array of index providers for optimized querying.
+	* @param options.enableDebugMode - A boolean to enable or disable debug mode.
+	*/
+	constructor(options) {
+		const replicationAdapter = createReplicationAdapter({
+			registerRemoteChange: options.registerRemoteChange,
+			pull: async () => {
+				this.isPullingRemoteSignal.set(true);
+				try {
+					return await options.pull();
+				} finally {
+					this.isPullingRemoteSignal.set(false);
+				}
+			},
+			push: options.push ? async (changes, items) => {
+				if (!options.push) throw new Error("Pushing is not configured for this collection. Try to pass a `push` function to the collection options.");
+				this.isPushingRemoteSignal.set(true);
+				try {
+					await options.push(changes, items);
+				} finally {
+					this.isPushingRemoteSignal.set(false);
+				}
+			} : void 0
+		});
+		const persistenceAdapter = options?.persistence ? combinePersistenceAdapters(replicationAdapter, options.persistence) : replicationAdapter;
+		super({
+			...options,
+			persistence: persistenceAdapter
+		});
+		this.isPullingRemoteSignal = createSignal(options.reactivity, false);
+		this.isPushingRemoteSignal = createSignal(options.reactivity, false);
+	}
+	/**
+	* Checks whether the collection is currently performing any loading operation,
+	* including pulling or pushing data from/to the remote source, or standard
+	* persistence adapter operations.
+	* ⚡️ this function is reactive!
+	* @returns A boolean indicating if the collection is currently loading or synchronizing.
+	*/
+	isLoading() {
+		const isPullingRemote = this.isPullingRemoteSignal.get();
+		const isPushingRemote = this.isPushingRemoteSignal.get();
+		const isLoading = super.isLoading();
+		return isPullingRemote || isPushingRemote || isLoading;
+	}
 };
+//#endregion
+export { ReplicatedCollection as default };

package/dist/index27.cjs.js

@@ -0,0 +1,154 @@
+const require_createSignal = require("./index16.cjs.js");
+const require_ReplicatedCollection = require("./index26.cjs.js");
+//#region src/AutoFetchCollection.ts
+/**
+* A special collection that automatically fetches items when they are needed.
+*/
+var AutoFetchCollection = class extends require_ReplicatedCollection.default {
+	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 = require_createSignal.default(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), require_createSignal.default(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
+exports.default = AutoFetchCollection;