@nlozgachev/pipelined 0.41.0 → 0.43.0

package/dist/InternalTypes-DsCqxWZm.d.mts

@@ -0,0 +1,118 @@
+import { Duration } from './types.mjs';
+
+declare const _deferred: unique symbol;
+/**
+ * A nominally typed, one-shot async value that supports `await` but enforces infallibility.
+ *
+ * Two design choices work together to make the guarantee structural rather than documentary:
+ *
+ * - The phantom `[_deferred]` symbol makes the type **nominal**: only values produced by
+ *   `Deferred.fromPromise` satisfy it. A plain object `{ then: ... }` does not.
+ * - The single-parameter `.then()` **excludes rejection handlers** by construction. There is
+ *   no second argument to pass, so chaining and `.catch()` are impossible.
+ *
+ * This makes `Deferred<A>` the natural return type for `Task<A>`, which is guaranteed to
+ * never reject.
+ *
+ * @example
+ * ```ts
+ * const value = await Deferred.fromPromise(Promise.resolve(42));
+ * // value === 42
+ * ```
+ */
+type Deferred<A> = {
+    readonly [_deferred]: A;
+    readonly then: (onfulfilled: (value: A) => unknown) => void;
+};
+declare namespace Deferred {
+    /**
+     * Wraps a `Promise` or `Deferred` into a `Deferred`, structurally excluding rejection handlers,
+     * `.catch()`, `.finally()`, and chainable `.then()`.
+     *
+     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
+     * never resolve — `await`-ing it will hang indefinitely. Use `TaskResult.tryCatch` to
+     * handle operations that may fail before converting to a `Deferred`.
+     *
+     * @example
+     * ```ts
+     * const d = Deferred.fromPromise(Promise.resolve("hello"));
+     * const value = await d; // "hello"
+     * ```
+     */
+    const fromPromise: <A>(p: Thenable<A>) => Deferred<A>;
+    /**
+     * Converts a `Deferred` back into a `Promise`.
+     *
+     * @example
+     * ```ts
+     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
+     * // p is Promise<42>
+     * ```
+     */
+    const toPromise: <A>(d: Deferred<A>) => Promise<A>;
+}
+
+/**
+ * Represents a promise-like object or a deferred value that can be resolved with `.then()`.
+ */
+type Thenable<A> = PromiseLike<A> | Deferred<A>;
+/**
+ * Represents a value that can be either a synchronous value or a Thenable.
+ */
+type Awaitable<A> = A | Thenable<A>;
+type NonEmptyArr<A> = readonly [A, ...A[]];
+type WithKind<K extends string> = {
+    readonly kind: K;
+};
+type WithValue<T> = {
+    readonly value: T;
+};
+type WithError<T> = {
+    readonly error: T;
+};
+type WithErrors<T> = {
+    readonly errors: NonEmptyArr<T>;
+};
+type WithFirst<T> = {
+    readonly first: T;
+};
+type WithSecond<T> = {
+    readonly second: T;
+};
+type WithLog<T> = {
+    readonly log: ReadonlyArray<T>;
+};
+/** Retry policy for `Op.interpret`. */
+type RetryOptions<E> = {
+    readonly attempts: number;
+    readonly backoff?: Duration | ((attempt: number) => Duration);
+    readonly when?: (error: E) => boolean;
+};
+/** Timeout policy for `Op.interpret`. Wraps the entire retry sequence. */
+type TimeoutOptions<E> = {
+    readonly duration: Duration;
+    readonly onTimeout: () => E;
+};
+type WithTimeout<E> = {
+    readonly timeout?: TimeoutOptions<E>;
+};
+type WithDuration = {
+    readonly duration: Duration;
+};
+type WithN = {
+    readonly n: number;
+};
+type WithConcurrency = {
+    readonly concurrency?: number;
+};
+type WithSize = {
+    readonly size?: number;
+};
+type WithCooldown = {
+    readonly cooldown?: Duration;
+};
+type WithMinInterval = {
+    readonly minInterval?: Duration;
+};
+
+export { type Awaitable as A, Deferred as D, type NonEmptyArr as N, type RetryOptions as R, type Thenable as T, type WithConcurrency as W, type TimeoutOptions as a, type WithCooldown as b, type WithDuration as c, type WithError as d, type WithErrors as e, type WithFirst as f, type WithKind as g, type WithLog as h, type WithMinInterval as i, type WithN as j, type WithSecond as k, type WithSize as l, type WithTimeout as m, type WithValue as n };

package/dist/InternalTypes-DuzMFAfJ.d.ts

@@ -0,0 +1,118 @@
+import { Duration } from './types.js';
+
+declare const _deferred: unique symbol;
+/**
+ * A nominally typed, one-shot async value that supports `await` but enforces infallibility.
+ *
+ * Two design choices work together to make the guarantee structural rather than documentary:
+ *
+ * - The phantom `[_deferred]` symbol makes the type **nominal**: only values produced by
+ *   `Deferred.fromPromise` satisfy it. A plain object `{ then: ... }` does not.
+ * - The single-parameter `.then()` **excludes rejection handlers** by construction. There is
+ *   no second argument to pass, so chaining and `.catch()` are impossible.
+ *
+ * This makes `Deferred<A>` the natural return type for `Task<A>`, which is guaranteed to
+ * never reject.
+ *
+ * @example
+ * ```ts
+ * const value = await Deferred.fromPromise(Promise.resolve(42));
+ * // value === 42
+ * ```
+ */
+type Deferred<A> = {
+    readonly [_deferred]: A;
+    readonly then: (onfulfilled: (value: A) => unknown) => void;
+};
+declare namespace Deferred {
+    /**
+     * Wraps a `Promise` or `Deferred` into a `Deferred`, structurally excluding rejection handlers,
+     * `.catch()`, `.finally()`, and chainable `.then()`.
+     *
+     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
+     * never resolve — `await`-ing it will hang indefinitely. Use `TaskResult.tryCatch` to
+     * handle operations that may fail before converting to a `Deferred`.
+     *
+     * @example
+     * ```ts
+     * const d = Deferred.fromPromise(Promise.resolve("hello"));
+     * const value = await d; // "hello"
+     * ```
+     */
+    const fromPromise: <A>(p: Thenable<A>) => Deferred<A>;
+    /**
+     * Converts a `Deferred` back into a `Promise`.
+     *
+     * @example
+     * ```ts
+     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
+     * // p is Promise<42>
+     * ```
+     */
+    const toPromise: <A>(d: Deferred<A>) => Promise<A>;
+}
+
+/**
+ * Represents a promise-like object or a deferred value that can be resolved with `.then()`.
+ */
+type Thenable<A> = PromiseLike<A> | Deferred<A>;
+/**
+ * Represents a value that can be either a synchronous value or a Thenable.
+ */
+type Awaitable<A> = A | Thenable<A>;
+type NonEmptyArr<A> = readonly [A, ...A[]];
+type WithKind<K extends string> = {
+    readonly kind: K;
+};
+type WithValue<T> = {
+    readonly value: T;
+};
+type WithError<T> = {
+    readonly error: T;
+};
+type WithErrors<T> = {
+    readonly errors: NonEmptyArr<T>;
+};
+type WithFirst<T> = {
+    readonly first: T;
+};
+type WithSecond<T> = {
+    readonly second: T;
+};
+type WithLog<T> = {
+    readonly log: ReadonlyArray<T>;
+};
+/** Retry policy for `Op.interpret`. */
+type RetryOptions<E> = {
+    readonly attempts: number;
+    readonly backoff?: Duration | ((attempt: number) => Duration);
+    readonly when?: (error: E) => boolean;
+};
+/** Timeout policy for `Op.interpret`. Wraps the entire retry sequence. */
+type TimeoutOptions<E> = {
+    readonly duration: Duration;
+    readonly onTimeout: () => E;
+};
+type WithTimeout<E> = {
+    readonly timeout?: TimeoutOptions<E>;
+};
+type WithDuration = {
+    readonly duration: Duration;
+};
+type WithN = {
+    readonly n: number;
+};
+type WithConcurrency = {
+    readonly concurrency?: number;
+};
+type WithSize = {
+    readonly size?: number;
+};
+type WithCooldown = {
+    readonly cooldown?: Duration;
+};
+type WithMinInterval = {
+    readonly minInterval?: Duration;
+};
+
+export { type Awaitable as A, Deferred as D, type NonEmptyArr as N, type RetryOptions as R, type Thenable as T, type WithConcurrency as W, type TimeoutOptions as a, type WithCooldown as b, type WithDuration as c, type WithError as d, type WithErrors as e, type WithFirst as f, type WithKind as g, type WithLog as h, type WithMinInterval as i, type WithN as j, type WithSecond as k, type WithSize as l, type WithTimeout as m, type WithValue as n };