@signaldb/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/index32.cjs.js

@@ -0,0 +1,90 @@
+//#region src/utils/reactiveOrAsync.ts
+/**
+* A generator helper that makes TypeScript infer the “synchronous value type” for maybe-async expressions.
+*
+* Usage:
+*   const doc = yield* unwrap(Collection.findOne(...))
+*   const list = yield* unwrap(Collection.find(...).fetch())
+*
+* Runtime note:
+*   This does not “unwrap” Promises by itself. It yields the value/Promise to the runner and returns the
+*   value that the runner feeds back via `.next(...)`.
+* @param value The value (or Promise of a value) to yield to the runner.
+* @returns A generator that yields `value` and resolves to the runner-supplied unwrapped `T`.
+*/
+function unwrap(value) {
+	return (function* () {
+		return yield value;
+	})();
+}
+/**
+* Internal: checks for thenables (Promise-like).
+* @param value The value to test.
+* @returns `true` if `value` looks like a Promise/thenable.
+*/
+function isThenable(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+/**
+* Internal runner: executes a generator either synchronously (reactive) or asynchronously (imperative).
+*
+* - In sync mode, yielding a Promise is a programming error and throws.
+* - In async mode, yielded Promises are awaited.
+* @param thisArgument The `this` value to bind when invoking `gen`.
+* @param mode Execution mode options.
+* @param gen The generator workflow to run.
+* @returns The workflow result (a plain value in sync mode, or a Promise in async mode).
+*/
+function runReactiveOrAsync(thisArgument, mode, gen) {
+	const a = !!mode?.async;
+	const it = gen.call(thisArgument, a);
+	if (!a) {
+		let step = it.next();
+		while (!step.done) {
+			const y = step.value;
+			if (isThenable(y)) throw new Error("Promise yielded in sync flow");
+			step = it.next(y);
+		}
+		return step.value;
+	}
+	return (async function() {
+		let step = it.next();
+		while (!step.done) {
+			const y = step.value;
+			const v = isThenable(y) ? await y : y;
+			step = it.next(v);
+		}
+		return step.value;
+	})();
+}
+/**
+* Factory that turns a generator workflow into a callable method that can run in sync (reactive) or async mode.
+*
+* Call style:
+*   fn(a, b)                        -> sync/reactive return
+*   await fn(a, b, { async: true }) -> async return
+* @param gen Generator workflow. Receives `(a)` which indicates async mode and should `yield`/`yield* unwrap(...)`
+*   any values that may be Promises.
+* @returns A callable method with overloads plus a `.generator` property for composition.
+*/
+function reactiveOrAsync(gen) {
+	/**
+	* The generated method wrapper.
+	* @param allArguments Method arguments, optionally ending with a `ModeOptions` object.
+	* @returns The workflow result (sync) or a Promise of the result (async).
+	*/
+	function method(...allArguments) {
+		const last = allArguments.length > 0 ? allArguments.at(-1) : void 0;
+		const hasMode = typeof last === "object" && last !== null && "async" in last;
+		const mode = hasMode ? last : void 0;
+		const parameters = hasMode ? allArguments.slice(0, -1) : allArguments;
+		return runReactiveOrAsync(this, mode, function* (a) {
+			return yield* gen.call(this, a, ...parameters);
+		});
+	}
+	method.generator = gen;
+	return method;
+}
+//#endregion
+exports.default = reactiveOrAsync;
+exports.unwrap = unwrap;

package/dist/index32.mjs

@@ -1,10 +1,89 @@
-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 {
-  uniqueBy as default
-};
+//#region src/utils/reactiveOrAsync.ts
+/**
+* A generator helper that makes TypeScript infer the “synchronous value type” for maybe-async expressions.
+*
+* Usage:
+*   const doc = yield* unwrap(Collection.findOne(...))
+*   const list = yield* unwrap(Collection.find(...).fetch())
+*
+* Runtime note:
+*   This does not “unwrap” Promises by itself. It yields the value/Promise to the runner and returns the
+*   value that the runner feeds back via `.next(...)`.
+* @param value The value (or Promise of a value) to yield to the runner.
+* @returns A generator that yields `value` and resolves to the runner-supplied unwrapped `T`.
+*/
+function unwrap(value) {
+	return (function* () {
+		return yield value;
+	})();
+}
+/**
+* Internal: checks for thenables (Promise-like).
+* @param value The value to test.
+* @returns `true` if `value` looks like a Promise/thenable.
+*/
+function isThenable(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+/**
+* Internal runner: executes a generator either synchronously (reactive) or asynchronously (imperative).
+*
+* - In sync mode, yielding a Promise is a programming error and throws.
+* - In async mode, yielded Promises are awaited.
+* @param thisArgument The `this` value to bind when invoking `gen`.
+* @param mode Execution mode options.
+* @param gen The generator workflow to run.
+* @returns The workflow result (a plain value in sync mode, or a Promise in async mode).
+*/
+function runReactiveOrAsync(thisArgument, mode, gen) {
+	const a = !!mode?.async;
+	const it = gen.call(thisArgument, a);
+	if (!a) {
+		let step = it.next();
+		while (!step.done) {
+			const y = step.value;
+			if (isThenable(y)) throw new Error("Promise yielded in sync flow");
+			step = it.next(y);
+		}
+		return step.value;
+	}
+	return (async function() {
+		let step = it.next();
+		while (!step.done) {
+			const y = step.value;
+			const v = isThenable(y) ? await y : y;
+			step = it.next(v);
+		}
+		return step.value;
+	})();
+}
+/**
+* Factory that turns a generator workflow into a callable method that can run in sync (reactive) or async mode.
+*
+* Call style:
+*   fn(a, b)                        -> sync/reactive return
+*   await fn(a, b, { async: true }) -> async return
+* @param gen Generator workflow. Receives `(a)` which indicates async mode and should `yield`/`yield* unwrap(...)`
+*   any values that may be Promises.
+* @returns A callable method with overloads plus a `.generator` property for composition.
+*/
+function reactiveOrAsync(gen) {
+	/**
+	* The generated method wrapper.
+	* @param allArguments Method arguments, optionally ending with a `ModeOptions` object.
+	* @returns The workflow result (sync) or a Promise of the result (async).
+	*/
+	function method(...allArguments) {
+		const last = allArguments.length > 0 ? allArguments.at(-1) : void 0;
+		const hasMode = typeof last === "object" && last !== null && "async" in last;
+		const mode = hasMode ? last : void 0;
+		const parameters = hasMode ? allArguments.slice(0, -1) : allArguments;
+		return runReactiveOrAsync(this, mode, function* (a) {
+			return yield* gen.call(this, a, ...parameters);
+		});
+	}
+	method.generator = gen;
+	return method;
+}
+//#endregion
+export { reactiveOrAsync as default, unwrap };

package/dist/index33.cjs.js

@@ -0,0 +1,53 @@
+const require_getMatchingKeys = require("./index14.cjs.js");
+//#region src/utils/storageIndexQuery.ts
+/**
+* Builds the index provider a data adapter uses to narrow a selector down through
+* a storage adapter's index.
+*
+* Every adapter that keeps its data in a `StorageAdapter` needs exactly this, and
+* each of them used to carry its own copy — three transcriptions of one set of
+* rules about null, `$exists`, inclusion and exclusion, which is how they drift
+* apart without anyone noticing. The index is keyed by `serializeValue(value)`,
+* which is what `getMatchingKeys` produces, so the two only agree while they stay
+* in one place.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param storage - The storage adapter holding the index.
+* @param field - The indexed field this provider answers for.
+* @returns A query function for `getIndexInfo`.
+*/
+function storageIndexQuery(storage, field) {
+	return async (flatSelector) => {
+		if (!Object.hasOwnProperty.call(flatSelector, field)) return { matched: false };
+		const index = await storage.readIndex(field);
+		const fieldSelector = flatSelector[field];
+		const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
+		const keys = filtersForNull ? {
+			include: null,
+			exclude: [...index.keys()].filter((key) => key != null)
+		} : require_getMatchingKeys.default(field, flatSelector);
+		if (keys.include == null && keys.exclude == null) return { matched: false };
+		let includedIds = [];
+		if (keys.include == null) for (const set of index.values()) for (const id of set) includedIds.push(id);
+		else for (const key of keys.include) {
+			const idSet = index.get(key);
+			if (idSet) for (const id of idSet) includedIds.push(id);
+		}
+		if (keys.exclude != null) {
+			const excludedIds = /* @__PURE__ */ new Set();
+			for (const key of keys.exclude) {
+				const idSet = index.get(key);
+				if (idSet) for (const id of idSet) excludedIds.add(id);
+			}
+			includedIds = includedIds.filter((id) => !excludedIds.has(id));
+		}
+		return {
+			matched: true,
+			ids: includedIds,
+			fields: [field],
+			keepSelector: filtersForNull
+		};
+	};
+}
+//#endregion
+exports.default = storageIndexQuery;

package/dist/index33.mjs

@@ -1,6 +1,53 @@
-function createIndexProvider(definition) {
-  return definition;
+import getMatchingKeys from "./index14.mjs";
+//#region src/utils/storageIndexQuery.ts
+/**
+* Builds the index provider a data adapter uses to narrow a selector down through
+* a storage adapter's index.
+*
+* Every adapter that keeps its data in a `StorageAdapter` needs exactly this, and
+* each of them used to carry its own copy — three transcriptions of one set of
+* rules about null, `$exists`, inclusion and exclusion, which is how they drift
+* apart without anyone noticing. The index is keyed by `serializeValue(value)`,
+* which is what `getMatchingKeys` produces, so the two only agree while they stay
+* in one place.
+* @template T - The type of the items in the collection.
+* @template I - The type of the unique identifier for the items.
+* @param storage - The storage adapter holding the index.
+* @param field - The indexed field this provider answers for.
+* @returns A query function for `getIndexInfo`.
+*/
+function storageIndexQuery(storage, field) {
+	return async (flatSelector) => {
+		if (!Object.hasOwnProperty.call(flatSelector, field)) return { matched: false };
+		const index = await storage.readIndex(field);
+		const fieldSelector = flatSelector[field];
+		const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
+		const keys = filtersForNull ? {
+			include: null,
+			exclude: [...index.keys()].filter((key) => key != null)
+		} : getMatchingKeys(field, flatSelector);
+		if (keys.include == null && keys.exclude == null) return { matched: false };
+		let includedIds = [];
+		if (keys.include == null) for (const set of index.values()) for (const id of set) includedIds.push(id);
+		else for (const key of keys.include) {
+			const idSet = index.get(key);
+			if (idSet) for (const id of idSet) includedIds.push(id);
+		}
+		if (keys.exclude != null) {
+			const excludedIds = /* @__PURE__ */ new Set();
+			for (const key of keys.exclude) {
+				const idSet = index.get(key);
+				if (idSet) for (const id of idSet) excludedIds.add(id);
+			}
+			includedIds = includedIds.filter((id) => !excludedIds.has(id));
+		}
+		return {
+			matched: true,
+			ids: includedIds,
+			fields: [field],
+			keepSelector: filtersForNull
+		};
+	};
 }
-export {
-  createIndexProvider as default
-};
+//#endregion
+export { storageIndexQuery as default };