@signaldb/core 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/utils/reactiveOrAsync.d.ts

@@ -0,0 +1,59 @@
+export type MaybePromise<T> = T | Promise<T>;
+/**
+ * Options that control execution mode (and potential future mode-specific behavior).
+ * Keep this minimal; you can extend it later (e.g. signal, timeoutMs, debugLabel).
+ */
+export type ModeOptions = {
+    async?: boolean;
+};
+/**
+ * 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`.
+ */
+export declare function unwrap<T>(value: MaybePromise<T>): Generator<MaybePromise<T>, T, T>;
+/**
+ * Generator shape used by the factory.
+ *
+ * `TThis` is the type of `this` inside the generator.
+ * `Args` are the method parameters (excluding the mode flag).
+ * `TReturn` is the final return value of the workflow.
+ * `TNext` is the type that is yielded/awaited and fed back via `.next(...)`.
+ *
+ * Note:
+ * - For best inference at yield sites, prefer `yield* unwrap(expr)` for maybe-async expressions.
+ */
+export type ReactiveOrAsyncGen<TThis, Arguments extends any[], TReturn, TNext> = (this: TThis, a: boolean, ...args: Arguments) => Generator<MaybePromise<TNext>, TReturn, TNext>;
+/**
+ * The method type produced from the generator signature.
+ * Adds overloads so that `{ async: true }` yields a `Promise<...>` return type.
+ */
+export type ReactiveOrAsyncMethod<TThis, P extends any[], R, N> = {
+    (this: TThis, ...args: P): R;
+    (this: TThis, ...args: [...P, ModeOptions?]): MaybePromise<R>;
+    (this: TThis, ...args: [...P, {
+        async: true;
+    }]): Promise<R>;
+} & {
+    /** Exposes the underlying generator for composition via `yield* method.generator.call(this, a, ...)` */
+    generator: (this: TThis, a: boolean, ...args: P) => Generator<MaybePromise<N>, R, N>;
+};
+/**
+ * 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.
+ */
+export default function reactiveOrAsync<TThis, P extends any[], R, N>(gen: (this: TThis, a: boolean, ...args: P) => Generator<MaybePromise<N>, R, N>): ReactiveOrAsyncMethod<TThis, P, R, N>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaldb/core",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.6",
   "description": "SignalDB is a client-side database that provides a simple MongoDB-like interface to the data with first-class typescript support to achieve an optimistic UI. Data persistence can be achieved by using storage providers that store the data through a JSON interface to places such as localStorage.",
   "scripts": {
     "build": "rimraf dist && vite build",