@nlozgachev/pipelined 0.43.0 → 0.45.0

package/README.md

@@ -17,7 +17,7 @@ npm add @nlozgachev/pipelined
 In mainstream TypeScript, code is often burdened by implicit control flow: unchecked exceptions,
 manual null propagation, and unhandled asynchronous failures. `pipelined` turns these complex
 runtime states into simple, transparent data structures that compose. By representing optionality as
-`Maybe`, failures as `Result`, lazy asynchronous pipelines as `TaskResult`, and repeated stateful
+`Maybe`, failures as `Result`, lazy asynchronous pipelines as `Task.Result`, and repeated stateful
 interactions as `Op`, the library helps disentangle business logic from control mechanics.
 
 ## Documentation
@@ -55,18 +55,18 @@ Every step that sees `None` is skipped. The fallback runs once, at the end.
 ## Example: typed async errors
 
 In JavaScript, asynchronous exceptions bypass the static type system, leaving unhandled rejections
-as invisible runtime risks. `TaskResult<E, A>` represents fallible asynchronous computations as
+as invisible runtime risks. `Task.Result<E, A>` represents fallible asynchronous computations as
 lazy, infallible tasks that resolve to a typed `Result`. The error type is explicitly tracked in the
 function signature, ensuring that failures are handled before compile time:
 
 ```ts
 import { pipe } from "@nlozgachev/pipelined/composition";
-import { Result, TaskResult } from "@nlozgachev/pipelined/core";
+import { Result, Task } from "@nlozgachev/pipelined/core";
 
 type ApiError = { status: number; message: string };
 
-const fetchUser = (id: string): TaskResult<ApiError, User> =>
-  TaskResult.tryCatch(
+const fetchUser = (id: string): Task.Result<ApiError, User> =>
+  Task.Result.tryCatch(
     (signal) =>
       fetch(`/users/${id}`, { signal }).then((r) => {
         if (!r.ok) throw { status: r.status, message: r.statusText };
@@ -75,8 +75,8 @@ const fetchUser = (id: string): TaskResult<ApiError, User> =>
     (e) => e as ApiError,
   );
 
-const fetchPosts = (userId: string): TaskResult<ApiError, Post[]> =>
-  TaskResult.tryCatch(
+const fetchPosts = (userId: string): Task.Result<ApiError, Post[]> =>
+  Task.Result.tryCatch(
     (signal) =>
       fetch(`/users/${userId}/posts`, { signal }).then((r) => r.json()),
     (e) => e as ApiError,
@@ -86,10 +86,10 @@ const fetchPosts = (userId: string): TaskResult<ApiError, Post[]> =>
 const userWithPosts = (id: string) =>
   pipe(
     fetchUser(id),
-    TaskResult.chain((user) =>
+    Task.Result.chain((user) =>
       pipe(
         fetchPosts(user.id),
-        TaskResult.map((posts) => ({ ...user, posts })),
+        Task.Result.map((posts) => ({ ...user, posts })),
       )
     ),
   );
@@ -103,7 +103,7 @@ const controller = new AbortController();
 const fetchUserWithPosts = userWithPosts("42"); // build the lazy task
 const result = await fetchUserWithPosts(controller.signal); // run it — signal controls cancellation
 
-if (Result.isOk(result)) {
+if (Result.is.ok(result)) {
   render(result.value); // { ...User, posts: Post[] }
 } else {
   showError(result.error); // ApiError — typed, not unknown
@@ -140,7 +140,7 @@ const cheapestByCategory = (items: RawItem[]) =>
     items,
     Arr.filterMap(normalise), // parse + drop unparseable prices in one pass
     Arr.sortBy((a, b) => a.price - b.price), // ascending price
-    Arr.groupBy((item) => item.category), // Record<string, NonEmptyList<Item>>
+    Arr.groupBy((item) => item.category), // Record<string, Arr.NonEmpty<Item>>
     Rec.map((group) => Arr.head(group)), // cheapest per category — Maybe<Item>
   );
 ```
@@ -314,7 +314,7 @@ provides a strongly-typed, immutable two-element pair.
 ### Asynchronous operations
 
 `Task` represents a lazy, infallible asynchronous computation. Fallible asynchronous workflows are
-handled by `TaskResult`, `TaskMaybe`, and `TaskValidation`. For managing stateful, recurring
+handled by `Task.Result`, `Task.Maybe`, and `Task.Validation`. For managing stateful, recurring
 asynchronous operations with complex scheduling, `Op` implements named concurrency strategies such
 as `restartable`, `exclusive`, `debounced`, `throttled`, and `queue`, handling retries, timeouts,
 and signal propagation automatically. `Deferred` represents a lightweight, infallible asynchronous
@@ -342,11 +342,12 @@ Functions are composed using `pipe` and `flow`, which are enriched with high-lev
 helpers like `when`, `unless`, `either`, `safe`, and `async` to support robust, expressive
 pipelines.
 
-### Nominal branding, durations, and non-empty lists
+### Nominal branding, durations, and non-empty collections
 
-Compile-time nominal typing with zero runtime overhead is provided by `Brand`, `Duration` safely
-models and converts time durations (seconds, milliseconds, etc.), and `NonEmptyList` guarantees that
-a list is never empty, eliminating defensive array length checks.
+Compile-time nominal typing with zero runtime overhead is provided by `Brand`. `Duration` safely
+models and converts time durations (seconds, milliseconds, etc.). `Arr.NonEmpty` and `Rec.NonEmpty`
+guarantee that an array or record is never empty, eliminating defensive length/emptiness checks at
+runtime.
 
 Every utility in the library is benchmarked against its native equivalent. The data-last currying
 adds a small function call overhead, which is the expected cost of composability. For operations

package/dist/{InternalTypes-DsCqxWZm.d.mts → InternalTypes-CLE7qlOc.d.mts}

@@ -7,7 +7,7 @@ declare const _deferred: unique symbol;
  * 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.
+ *   `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.
  *
@@ -16,7 +16,7 @@ declare const _deferred: unique symbol;
  *
  * @example
  * ```ts
- * const value = await Deferred.fromPromise(Promise.resolve(42));
+ * const value = await Deferred.from.Promise(Promise.resolve(42));
  * // value === 42
  * ```
  */
@@ -25,31 +25,35 @@ type 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>;
+    namespace 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"
+         * ```
+         */
+        const Promise: <A>(p: Thenable<A>) => Deferred<A>;
+    }
+    namespace 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>
+         * ```
+         */
+        const Promise: <A>(d: Deferred<A>) => globalThis.Promise<A>;
+    }
 }
 
 /**
@@ -114,5 +118,6 @@ type WithCooldown = {
 type WithMinInterval = {
     readonly minInterval?: Duration;
 };
+type NonEmpty<T extends string> = `NonEmpty${T}`;
 
-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 };
+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-DuzMFAfJ.d.ts → InternalTypes-Mssktd7z.d.ts}

@@ -7,7 +7,7 @@ declare const _deferred: unique symbol;
  * 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.
+ *   `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.
  *
@@ -16,7 +16,7 @@ declare const _deferred: unique symbol;
  *
  * @example
  * ```ts
- * const value = await Deferred.fromPromise(Promise.resolve(42));
+ * const value = await Deferred.from.Promise(Promise.resolve(42));
  * // value === 42
  * ```
  */
@@ -25,31 +25,35 @@ type 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>;
+    namespace 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"
+         * ```
+         */
+        const Promise: <A>(p: Thenable<A>) => Deferred<A>;
+    }
+    namespace 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>
+         * ```
+         */
+        const Promise: <A>(d: Deferred<A>) => globalThis.Promise<A>;
+    }
 }
 
 /**
@@ -114,5 +118,6 @@ type WithCooldown = {
 type WithMinInterval = {
     readonly minInterval?: Duration;
 };
+type NonEmpty<T extends string> = `NonEmpty${T}`;
 
-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 };
+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 };