@signaldb/core 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/index31.cjs.js

@@ -1,32 +1,90 @@
-const require_match = require("./index18.cjs.js");
-const require_project = require("./index21.cjs.js");
-const require_sortItems = require("./index23.cjs.js");
-//#region src/utils/applyQueryOptions.ts
+//#region src/utils/reactiveOrAsync.ts
 /**
-* Filters, sorts, paginates and projects a plain in-memory array the same way
-* DefaultDataAdapter and WorkerDataAdapterHost apply a selector/QueryOptions
-* pair to their stored items. Used to re-derive a query's result locally after
-* a write, without asking the backing store again.
-* @template T - The type of the items.
-* @param items - The items to filter, sort, paginate and project.
-* @param selector - The selector to match items against.
-* @param options - Sort, skip, limit and field projection options.
-* @returns The resulting items.
+* 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 applyQueryOptions(items, selector, options) {
-	const matched = selector == null ? [] : items.filter((item) => require_match.default(item, selector));
-	const { sort, skip, limit, fields } = options || {};
-	const sorted = sort ? require_sortItems.default(matched, sort) : matched;
-	const skipped = skip ? sorted.slice(skip) : sorted;
-	const limited = limit ? skipped.slice(0, limit) : skipped;
-	const idExcluded = fields && fields.id === 0;
-	return limited.map((item) => {
-		if (!fields) return item;
-		return {
-			...idExcluded ? {} : { id: item.id },
-			...require_project.default(item, fields)
-		};
-	});
+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 = applyQueryOptions;
+exports.default = reactiveOrAsync;
+exports.unwrap = unwrap;

package/dist/index31.mjs

@@ -1,32 +1,89 @@
-import match from "./index18.mjs";
-import project from "./index21.mjs";
-import sortItems from "./index23.mjs";
-//#region src/utils/applyQueryOptions.ts
+//#region src/utils/reactiveOrAsync.ts
 /**
-* Filters, sorts, paginates and projects a plain in-memory array the same way
-* DefaultDataAdapter and WorkerDataAdapterHost apply a selector/QueryOptions
-* pair to their stored items. Used to re-derive a query's result locally after
-* a write, without asking the backing store again.
-* @template T - The type of the items.
-* @param items - The items to filter, sort, paginate and project.
-* @param selector - The selector to match items against.
-* @param options - Sort, skip, limit and field projection options.
-* @returns The resulting items.
+* 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 applyQueryOptions(items, selector, options) {
-	const matched = selector == null ? [] : items.filter((item) => match(item, selector));
-	const { sort, skip, limit, fields } = options || {};
-	const sorted = sort ? sortItems(matched, sort) : matched;
-	const skipped = skip ? sorted.slice(skip) : sorted;
-	const limited = limit ? skipped.slice(0, limit) : skipped;
-	const idExcluded = fields && fields.id === 0;
-	return limited.map((item) => {
-		if (!fields) return item;
-		return {
-			...idExcluded ? {} : { id: item.id },
-			...project(item, fields)
-		};
-	});
+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 { applyQueryOptions as default };
+export { reactiveOrAsync as default, unwrap };