@signaldb/core 2.0.0-beta.17 → 2.0.0-beta.19

package/dist/index31.cjs.js

@@ -1,90 +1,11 @@
-//#region src/utils/reactiveOrAsync.ts
+//#region src/createReactivityAdapter.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`.
+* Creates an ReactivityAdapter based on the given definition.
+* @param definition - The definition of the ReactivityAdapter.
+* @returns The created ReactivityAdapter.
 */
-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;
+function createReactivityAdapter(definition) {
+	return definition;
 }
 //#endregion
-exports.default = reactiveOrAsync;
-exports.unwrap = unwrap;
+exports.default = createReactivityAdapter;

package/dist/index31.mjs

@@ -1,89 +1,11 @@
-//#region src/utils/reactiveOrAsync.ts
+//#region src/createReactivityAdapter.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`.
+* Creates an ReactivityAdapter based on the given definition.
+* @param definition - The definition of the ReactivityAdapter.
+* @returns The created ReactivityAdapter.
 */
-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;
+function createReactivityAdapter(definition) {
+	return definition;
 }
 //#endregion
-export { reactiveOrAsync as default, unwrap };
+export { createReactivityAdapter as default };