@nlozgachev/pipelined 0.63.0 → 0.65.0

package/dist/Duration-DeyxG6VQ.d.ts

@@ -1,181 +0,0 @@
-declare const _brand: unique symbol;
-/**
- * Brand<K, T> creates a nominal type by tagging T with a phantom brand K.
- * Prevents accidentally mixing up values that share the same underlying type.
- *
- * @example
- * ```ts
- * type UserId = Brand<"UserId", string>;
- * type ProductId = Brand<"ProductId", string>;
- *
- * const toUserId = Brand.wrap<"UserId", string>();
- * const toProductId = Brand.wrap<"ProductId", string>();
- *
- * const userId: UserId = toUserId("user-123");
- * const productId: ProductId = toProductId("prod-456");
- *
- * // Type error: ProductId is not assignable to UserId
- * // const wrong: UserId = productId;
- * ```
- */
-type Brand<K extends string, T> = T & {
-    readonly [_brand]: K;
-};
-declare const Brand: {
-    /**
-     * Returns a constructor that wraps a value of type T in brand K.
-     * The resulting function performs an unchecked cast — only use when the raw
-     * value is known to satisfy the brand's invariants.
-     *
-     * @example
-     * ```ts
-     * type PositiveNumber = Brand<"PositiveNumber", number>;
-     * const toPositiveNumber = Brand.wrap<"PositiveNumber", number>();
-     *
-     * const n: PositiveNumber = toPositiveNumber(42);
-     * ```
-     */
-    wrap: <K extends string, T>() => (value: T) => Brand<K, T>;
-    /**
-     * Strips the brand and returns the underlying value.
-     * Since Brand<K, T> extends T this is rarely needed, but can improve readability.
-     *
-     * @example
-     * ```ts
-     * type UserId = Brand<"UserId", string>;
-     * const toUserId = Brand.wrap<"UserId", string>();
-     * const userId: UserId = toUserId("user-123");
-     * const raw: string = Brand.unwrap(userId); // "user-123"
-     * ```
-     */
-    unwrap: <K extends string, T>(branded: Brand<K, T>) => T;
-};
-
-/**
- * A branded nominal type representing a duration of time in milliseconds.
- * Use Duration to ensure safe time-based operators and clear unit conversions.
- *
- * @example
- * ```ts
- * const halfSecond = Duration.milliseconds(500);
- * const twoSeconds = Duration.seconds(2);
- * const total = pipe(halfSecond, Duration.add(twoSeconds));
- *
- * Duration.to.seconds(total); // 2.5
- * ```
- */
-type Duration = Brand<"Duration", number>;
-declare const Duration: {
-    /**
-     * Creates a Duration from milliseconds.
-     *
-     * @example
-     * ```ts
-     * Duration.milliseconds(500); // 500ms Duration
-     * ```
-     */
-    milliseconds: (ms: number) => Duration;
-    /**
-     * Creates a Duration from seconds.
-     *
-     * @example
-     * ```ts
-     * Duration.seconds(2); // 2000ms Duration
-     * ```
-     */
-    seconds: (s: number) => Duration;
-    /**
-     * Creates a Duration from minutes.
-     *
-     * @example
-     * ```ts
-     * Duration.minutes(5); // 300000ms Duration
-     * ```
-     */
-    minutes: (m: number) => Duration;
-    /**
-     * Creates a Duration from hours.
-     *
-     * @example
-     * ```ts
-     * Duration.hours(1); // 3600000ms Duration
-     * ```
-     */
-    hours: (h: number) => Duration;
-    /**
-     * Creates a Duration from days.
-     *
-     * @example
-     * ```ts
-     * Duration.days(1); // 86400000ms Duration
-     * ```
-     */
-    days: (d: number) => Duration;
-    to: {
-        /**
-         * Converts a Duration back to raw milliseconds.
-         *
-         * @example
-         * ```ts
-         * Duration.to.milliseconds(Duration.seconds(2)); // 2000
-         * ```
-         */
-        milliseconds: (d: Duration) => number;
-        /**
-         * Converts a Duration to seconds.
-         *
-         * @example
-         * ```ts
-         * Duration.to.seconds(Duration.milliseconds(2500)); // 2.5
-         * ```
-         */
-        seconds: (d: Duration) => number;
-        /**
-         * Converts a Duration to minutes.
-         *
-         * @example
-         * ```ts
-         * Duration.to.minutes(Duration.seconds(120)); // 2
-         * ```
-         */
-        minutes: (d: Duration) => number;
-        /**
-         * Converts a Duration to hours.
-         *
-         * @example
-         * ```ts
-         * Duration.to.hours(Duration.minutes(90)); // 1.5
-         * ```
-         */
-        hours: (d: Duration) => number;
-        /**
-         * Converts a Duration to days.
-         *
-         * @example
-         * ```ts
-         * Duration.to.days(Duration.hours(36)); // 1.5
-         * ```
-         */
-        days: (d: Duration) => number;
-    };
-    /**
-     * Adds two Durations together.
-     *
-     * @example
-     * ```ts
-     * pipe(Duration.seconds(1), Duration.add(Duration.milliseconds(500))); // 1500ms
-     * ```
-     */
-    add: (other: Duration) => (self: Duration) => Duration;
-    /**
-     * Subtracts the other Duration from this one.
-     *
-     * @example
-     * ```ts
-     * pipe(Duration.seconds(1), Duration.subtract(Duration.milliseconds(500))); // 500ms
-     * ```
-     */
-    subtract: (other: Duration) => (self: Duration) => Duration;
-};
-
-export { Brand as B, Duration as D };

package/dist/InternalTypes-CCXa8Kvr.d.ts

@@ -1,142 +0,0 @@
-import { D as Duration } from './Duration-DeyxG6VQ.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.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>;
-};
-
-/**
- * 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}`;
-
-export { type Awaitable as A, Deferred as D, type NonEmpty as N, type RetryOptions as R, type Thenable as T, type WithConcurrency as W, type NonEmptyArr as a, type TimeoutOptions as b, type WithCooldown as c, type WithDuration as d, type WithError as e, type WithErrors as f, type WithFirst as g, type WithKind as h, type WithLog as i, type WithMinInterval as j, type WithN as k, type WithSecond as l, type WithSize as m, type WithTimeout as n, type WithValue as o };

package/dist/InternalTypes-GFn4RTwD.d.cts

@@ -1,142 +0,0 @@
-import { D as Duration } from './Duration-DeyxG6VQ.cjs';
-
-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>;
-};
-
-/**
- * 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}`;
-
-export { type Awaitable as A, Deferred as D, type NonEmpty as N, type RetryOptions as R, type Thenable as T, type WithConcurrency as W, type NonEmptyArr as a, type TimeoutOptions as b, type WithCooldown as c, type WithDuration as d, type WithError as e, type WithErrors as f, type WithFirst as g, type WithKind as h, type WithLog as i, type WithMinInterval as j, type WithN as k, type WithSecond as l, type WithSize as m, type WithTimeout as n, type WithValue as o };