@nlozgachev/pipelined 0.64.0 → 0.66.0

package/dist/InternalTypes-B1Lh9uw_.d.cts

@@ -0,0 +1,143 @@
+import { n as Duration } from "./index-Bs8En5LJ.cjs";
+//#region src/Core/Deferred.d.ts
+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.from.Promise` 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.from.Promise(Promise.resolve(42));
+ * // value === 42
+ * ```
+ */
+type Deferred<A> = {
+  readonly [_deferred]: A;
+  readonly then: (onfulfilled: (value: A) => unknown) => void;
+};
+declare const Deferred: {
+  from: {
+    /**
+     * 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 `Task.Result.tryCatch` to
+     * handle operations that may fail before converting to a `Deferred`.
+     *
+     * @example
+     * ```ts
+     * const d = Deferred.from.Promise(Promise.resolve("hello"));
+     * const value = await d; // "hello"
+     * ```
+     */
+    Promise: <A>(p: Thenable<A>) => Deferred<A>;
+  };
+  to: {
+    /**
+     * Converts a `Deferred` back into a `Promise`.
+     *
+     * @example
+     * ```ts
+     * const p = Deferred.to.Promise(Deferred.from.Promise(Promise.resolve(42)));
+     * // p is Promise<42>
+     * ```
+     */
+    Promise: <A>(d: Deferred<A>) => globalThis.Promise<A>;
+  };
+  /**
+   * Combines an array or tuple of `Deferred` values into a single `Deferred` of a tuple.
+   * Resolves when all input `Deferred`s resolve.
+   *
+   * @example
+   * ```ts
+   * const [a, b] = await Deferred.all([d1, d2]);
+   * ```
+   */
+  all: <T extends readonly Deferred<unknown>[]>(deferreds: T) => Deferred<{ [K in keyof T]: T[K] extends Deferred<infer A> ? A : never; }>;
+  /**
+   * Races multiple `Deferred` values and resolves with the first one to settle.
+   *
+   * @example
+   * ```ts
+   * const winner = await Deferred.race([d1, d2]);
+   * ```
+   */
+  race: <A>(deferreds: ReadonlyArray<Deferred<A>>) => Deferred<A>;
+};
+//#endregion
+//#region src/internal/InternalTypes.d.ts
+/**
+ * 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;
+};
+type NonEmpty<T extends string> = `NonEmpty${T}`;
+//#endregion
+export { WithSecond as _, Thenable as a, WithValue as b, WithCooldown as c, WithErrors as d, WithFirst as f, WithN as g, WithMinInterval as h, RetryOptions as i, WithDuration as l, WithLog as m, NonEmpty as n, TimeoutOptions as o, WithKind as p, NonEmptyArr as r, WithConcurrency as s, Awaitable as t, WithError as u, WithSize as v, Deferred as x, WithTimeout as y };

package/dist/InternalTypes-DzDey5Do.d.ts

@@ -0,0 +1,143 @@
+import { n as Duration } from "./index-Bs8En5LJ.js";
+//#region src/Core/Deferred.d.ts
+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.from.Promise` 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.from.Promise(Promise.resolve(42));
+ * // value === 42
+ * ```
+ */
+type Deferred<A> = {
+  readonly [_deferred]: A;
+  readonly then: (onfulfilled: (value: A) => unknown) => void;
+};
+declare const Deferred: {
+  from: {
+    /**
+     * 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 `Task.Result.tryCatch` to
+     * handle operations that may fail before converting to a `Deferred`.
+     *
+     * @example
+     * ```ts
+     * const d = Deferred.from.Promise(Promise.resolve("hello"));
+     * const value = await d; // "hello"
+     * ```
+     */
+    Promise: <A>(p: Thenable<A>) => Deferred<A>;
+  };
+  to: {
+    /**
+     * Converts a `Deferred` back into a `Promise`.
+     *
+     * @example
+     * ```ts
+     * const p = Deferred.to.Promise(Deferred.from.Promise(Promise.resolve(42)));
+     * // p is Promise<42>
+     * ```
+     */
+    Promise: <A>(d: Deferred<A>) => globalThis.Promise<A>;
+  };
+  /**
+   * Combines an array or tuple of `Deferred` values into a single `Deferred` of a tuple.
+   * Resolves when all input `Deferred`s resolve.
+   *
+   * @example
+   * ```ts
+   * const [a, b] = await Deferred.all([d1, d2]);
+   * ```
+   */
+  all: <T extends readonly Deferred<unknown>[]>(deferreds: T) => Deferred<{ [K in keyof T]: T[K] extends Deferred<infer A> ? A : never; }>;
+  /**
+   * Races multiple `Deferred` values and resolves with the first one to settle.
+   *
+   * @example
+   * ```ts
+   * const winner = await Deferred.race([d1, d2]);
+   * ```
+   */
+  race: <A>(deferreds: ReadonlyArray<Deferred<A>>) => Deferred<A>;
+};
+//#endregion
+//#region src/internal/InternalTypes.d.ts
+/**
+ * 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;
+};
+type NonEmpty<T extends string> = `NonEmpty${T}`;
+//#endregion
+export { WithSecond as _, Thenable as a, WithValue as b, WithCooldown as c, WithErrors as d, WithFirst as f, WithN as g, WithMinInterval as h, RetryOptions as i, WithDuration as l, WithLog as m, NonEmpty as n, TimeoutOptions as o, WithKind as p, NonEmptyArr as r, WithConcurrency as s, Awaitable as t, WithError as u, WithSize as v, Deferred as x, WithTimeout as y };