@nlozgachev/pipelined 0.32.0 → 0.34.0

package/dist/index.mjs

@@ -26,7 +26,7 @@ import {
   uncurry,
   uncurry3,
   uncurry4
-} from "./chunk-NRF2FVPZ.mjs";
+} from "./chunk-AHEZFTMT.mjs";
 import {
   Combinable,
   Equality,
@@ -48,7 +48,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-L3NC44SN.mjs";
+} from "./chunk-5AWUAG7G.mjs";
 import {
   Arr,
   Dict,
@@ -56,25 +56,28 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-EHQFUWZW.mjs";
+} from "./chunk-IJFFWBKW.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-TK5ZCGP2.mjs";
-import {
-  Brand
-} from "./chunk-BYWKZLHM.mjs";
+} from "./chunk-DLBHVYII.mjs";
+import "./chunk-IPP4XFYH.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";
+import {
+  Brand,
+  Duration
+} from "./chunk-VWVPHDZO.mjs";
 export {
   Arr,
   Brand,
   Combinable,
   Deferred,
   Dict,
+  Duration,
   Equality,
   Lazy,
   Lens,

package/dist/types.d.mts

@@ -1,4 +1,31 @@
-export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+/**
+ * A list that is guaranteed to have at least one element.
+ * Useful for ensuring functions receive non-empty input and for
+ * accumulating errors in Validation.
+ *
+ * @example
+ * ```ts
+ * const errors: NonEmptyList<string> = ["First error", "Second error"];
+ *
+ * // TypeScript ensures at least one element:
+ * const invalid: NonEmptyList<string> = []; // Error!
+ * ```
+ */
+type NonEmptyList<A> = readonly [A, ...A[]];
+/**
+ * Type guard that checks if an array is non-empty.
+ *
+ * @example
+ * ```ts
+ * const items: string[] = getItems();
+ *
+ * if (isNonEmptyList(items)) {
+ *   // TypeScript knows items has at least one element
+ *   const first = items[0]; // string, not string | undefined
+ * }
+ * ```
+ */
+declare const isNonEmptyList: <A>(list: readonly A[]) => list is NonEmptyList<A>;
 
 declare const _brand: unique symbol;
 /**
@@ -51,4 +78,79 @@ declare namespace Brand {
     const unwrap: <K extends string, T>(branded: Brand<K, T>) => T;
 }
 
-export { Brand };
+/**
+ * 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.toSeconds(total); // 2.5
+ * ```
+ */
+type Duration = Brand<"Duration", number>;
+declare namespace Duration {
+    /**
+     * Creates a Duration from milliseconds.
+     */
+    const milliseconds: (ms: number) => Duration;
+    /**
+     * Creates a Duration from seconds.
+     */
+    const seconds: (s: number) => Duration;
+    /**
+     * Creates a Duration from minutes.
+     */
+    const minutes: (m: number) => Duration;
+    /**
+     * Creates a Duration from hours.
+     */
+    const hours: (h: number) => Duration;
+    /**
+     * Creates a Duration from days.
+     */
+    const days: (d: number) => Duration;
+    /**
+     * Converts a Duration back to raw milliseconds.
+     */
+    const toMilliseconds: (d: Duration) => number;
+    /**
+     * Converts a Duration to seconds.
+     */
+    const toSeconds: (d: Duration) => number;
+    /**
+     * Converts a Duration to minutes.
+     */
+    const toMinutes: (d: Duration) => number;
+    /**
+     * Converts a Duration to hours.
+     */
+    const toHours: (d: Duration) => number;
+    /**
+     * Converts a Duration to days.
+     */
+    const toDays: (d: Duration) => number;
+    /**
+     * Adds two Durations together.
+     *
+     * @example
+     * ```ts
+     * pipe(Duration.seconds(1), Duration.add(Duration.milliseconds(500))); // 1500ms
+     * ```
+     */
+    const 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
+     * ```
+     */
+    const subtract: (other: Duration) => (self: Duration) => Duration;
+}
+
+export { Brand, Duration, type NonEmptyList, isNonEmptyList };

package/dist/types.d.ts

@@ -1,4 +1,31 @@
-export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.js';
+/**
+ * A list that is guaranteed to have at least one element.
+ * Useful for ensuring functions receive non-empty input and for
+ * accumulating errors in Validation.
+ *
+ * @example
+ * ```ts
+ * const errors: NonEmptyList<string> = ["First error", "Second error"];
+ *
+ * // TypeScript ensures at least one element:
+ * const invalid: NonEmptyList<string> = []; // Error!
+ * ```
+ */
+type NonEmptyList<A> = readonly [A, ...A[]];
+/**
+ * Type guard that checks if an array is non-empty.
+ *
+ * @example
+ * ```ts
+ * const items: string[] = getItems();
+ *
+ * if (isNonEmptyList(items)) {
+ *   // TypeScript knows items has at least one element
+ *   const first = items[0]; // string, not string | undefined
+ * }
+ * ```
+ */
+declare const isNonEmptyList: <A>(list: readonly A[]) => list is NonEmptyList<A>;
 
 declare const _brand: unique symbol;
 /**
@@ -51,4 +78,79 @@ declare namespace Brand {
     const unwrap: <K extends string, T>(branded: Brand<K, T>) => T;
 }
 
-export { Brand };
+/**
+ * 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.toSeconds(total); // 2.5
+ * ```
+ */
+type Duration = Brand<"Duration", number>;
+declare namespace Duration {
+    /**
+     * Creates a Duration from milliseconds.
+     */
+    const milliseconds: (ms: number) => Duration;
+    /**
+     * Creates a Duration from seconds.
+     */
+    const seconds: (s: number) => Duration;
+    /**
+     * Creates a Duration from minutes.
+     */
+    const minutes: (m: number) => Duration;
+    /**
+     * Creates a Duration from hours.
+     */
+    const hours: (h: number) => Duration;
+    /**
+     * Creates a Duration from days.
+     */
+    const days: (d: number) => Duration;
+    /**
+     * Converts a Duration back to raw milliseconds.
+     */
+    const toMilliseconds: (d: Duration) => number;
+    /**
+     * Converts a Duration to seconds.
+     */
+    const toSeconds: (d: Duration) => number;
+    /**
+     * Converts a Duration to minutes.
+     */
+    const toMinutes: (d: Duration) => number;
+    /**
+     * Converts a Duration to hours.
+     */
+    const toHours: (d: Duration) => number;
+    /**
+     * Converts a Duration to days.
+     */
+    const toDays: (d: Duration) => number;
+    /**
+     * Adds two Durations together.
+     *
+     * @example
+     * ```ts
+     * pipe(Duration.seconds(1), Duration.add(Duration.milliseconds(500))); // 1500ms
+     * ```
+     */
+    const 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
+     * ```
+     */
+    const subtract: (other: Duration) => (self: Duration) => Duration;
+}
+
+export { Brand, Duration, type NonEmptyList, isNonEmptyList };

package/dist/types.js

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var Types_exports = {};
 __export(Types_exports, {
   Brand: () => Brand,
+  Duration: () => Duration,
   isNonEmptyList: () => isNonEmptyList
 });
 module.exports = __toCommonJS(Types_exports);
@@ -32,10 +33,29 @@ var Brand;
   Brand2.unwrap = (branded) => branded;
 })(Brand || (Brand = {}));
 
+// src/Types/Duration.ts
+var Duration;
+((Duration2) => {
+  const wrap = Brand.wrap();
+  Duration2.milliseconds = (ms) => wrap(ms);
+  Duration2.seconds = (s) => wrap(s * 1e3);
+  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
+  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
+  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
+  Duration2.toMilliseconds = (d) => Brand.unwrap(d);
+  Duration2.toSeconds = (d) => Brand.unwrap(d) / 1e3;
+  Duration2.toMinutes = (d) => Brand.unwrap(d) / (60 * 1e3);
+  Duration2.toHours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
+  Duration2.toDays = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
+  Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
+})(Duration || (Duration = {}));
+
 // src/Types/NonEmptyList.ts
 var isNonEmptyList = (list) => list.length > 0;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Brand,
+  Duration,
   isNonEmptyList
 });

package/dist/types.mjs

@@ -1,10 +1,13 @@
-import {
-  Brand
-} from "./chunk-BYWKZLHM.mjs";
+import "./chunk-IPP4XFYH.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";
+import {
+  Brand,
+  Duration
+} from "./chunk-VWVPHDZO.mjs";
 export {
   Brand,
+  Duration,
   isNonEmptyList
 };

package/dist/utils.d.mts

@@ -1,5 +1,5 @@
-import { M as Maybe, E as Equality, b as Ordering, R as Result, T as Task } from './Task-CJZfcOkO.mjs';
-import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Task-DXsuurnc.mjs';
+import { NonEmptyList } from './types.mjs';
 
 /**
  * Functional array utilities that compose well with pipe.
@@ -140,6 +140,38 @@ declare namespace Arr {
      * ```
      */
     const partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
+    /**
+     * Narrows a list of Maybe values down to a list of their underlying values,
+     * discarding all None instances.
+     *
+     * @example
+     * ```ts
+     * Arr.compact([Maybe.some(1), Maybe.none(), Maybe.some(3)]); // [1, 3]
+     * ```
+     */
+    const compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
+    /**
+     * Separates an array of Result values into two separate lists of errors and successes.
+     * Returns a tuple containing `[errors, successes]`.
+     *
+     * @example
+     * ```ts
+     * Arr.separate([Result.ok(1), Result.err("bad"), Result.ok(3)]); // [["bad"], [1, 3]]
+     * ```
+     */
+    const separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
+    /**
+     * Maps each element to a Result, and separates the results into a tuple of failures and successes.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [1, 2, 3, 4],
+     *   Arr.partitionMap(n => n % 2 === 0 ? Result.ok(n) : Result.err(`odd: ${n}`))
+     * ); // [["odd: 1", "odd: 3"], [2, 4]]
+     * ```
+     */
+    const partitionMap: <A, E, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => readonly [readonly E[], readonly B[]];
     /**
      * Groups elements by a key function.
      *
@@ -277,7 +309,7 @@ declare namespace Arr {
      */
     const reduce: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => B;
     /**
-     * Maps each element to an Maybe and collects the results.
+     * Maps each element to a Maybe and collects the results.
      * Returns None if any mapping returns None.
      *
      * @example
@@ -300,7 +332,7 @@ declare namespace Arr {
      * ```ts
      * pipe(
      *   [1, 2, 3],
-     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.error("negative"))
+     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.err("negative"))
      * ); // Ok([1, 2, 3])
      * ```
      */
@@ -318,7 +350,7 @@ declare namespace Arr {
      */
     const traverseTask: <A, B>(f: (a: A) => Task<B>) => (data: readonly A[]) => Task<readonly B[]>;
     /**
-     * Collects an array of Options into an Maybe of array.
+     * Collects an array of Maybe instances into a Maybe of array.
      * Returns None if any element is None.
      *
      * @example
@@ -1041,6 +1073,7 @@ declare namespace Rec {
      * ```
      */
     const map: <A, B>(f: (a: A) => B) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
+    const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
     /**
      * Transforms each value in a record, also receiving the key.
      *
@@ -1390,6 +1423,16 @@ declare namespace Str {
          */
         float: (s: string) => Maybe<number>;
     };
+    /**
+     * Safely parses a JSON string, returning a `Result<SyntaxError, unknown>`.
+     *
+     * @example
+     * ```ts
+     * Str.parseJson('{"a": 1}'); // Ok({ a: 1 })
+     * Str.parseJson('invalid');  // Err(SyntaxError)
+     * ```
+     */
+    const parseJson: (s: string) => Result<SyntaxError, unknown>;
 }
 
 /**

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { M as Maybe, E as Equality, b as Ordering, R as Result, T as Task } from './Task-CjYKLeTY.js';
-import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Task-zAY4kSVB.js';
+import { NonEmptyList } from './types.js';
 
 /**
  * Functional array utilities that compose well with pipe.
@@ -140,6 +140,38 @@ declare namespace Arr {
      * ```
      */
     const partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
+    /**
+     * Narrows a list of Maybe values down to a list of their underlying values,
+     * discarding all None instances.
+     *
+     * @example
+     * ```ts
+     * Arr.compact([Maybe.some(1), Maybe.none(), Maybe.some(3)]); // [1, 3]
+     * ```
+     */
+    const compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
+    /**
+     * Separates an array of Result values into two separate lists of errors and successes.
+     * Returns a tuple containing `[errors, successes]`.
+     *
+     * @example
+     * ```ts
+     * Arr.separate([Result.ok(1), Result.err("bad"), Result.ok(3)]); // [["bad"], [1, 3]]
+     * ```
+     */
+    const separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
+    /**
+     * Maps each element to a Result, and separates the results into a tuple of failures and successes.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [1, 2, 3, 4],
+     *   Arr.partitionMap(n => n % 2 === 0 ? Result.ok(n) : Result.err(`odd: ${n}`))
+     * ); // [["odd: 1", "odd: 3"], [2, 4]]
+     * ```
+     */
+    const partitionMap: <A, E, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => readonly [readonly E[], readonly B[]];
     /**
      * Groups elements by a key function.
      *
@@ -277,7 +309,7 @@ declare namespace Arr {
      */
     const reduce: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => B;
     /**
-     * Maps each element to an Maybe and collects the results.
+     * Maps each element to a Maybe and collects the results.
      * Returns None if any mapping returns None.
      *
      * @example
@@ -300,7 +332,7 @@ declare namespace Arr {
      * ```ts
      * pipe(
      *   [1, 2, 3],
-     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.error("negative"))
+     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.err("negative"))
      * ); // Ok([1, 2, 3])
      * ```
      */
@@ -318,7 +350,7 @@ declare namespace Arr {
      */
     const traverseTask: <A, B>(f: (a: A) => Task<B>) => (data: readonly A[]) => Task<readonly B[]>;
     /**
-     * Collects an array of Options into an Maybe of array.
+     * Collects an array of Maybe instances into a Maybe of array.
      * Returns None if any element is None.
      *
      * @example
@@ -1041,6 +1073,7 @@ declare namespace Rec {
      * ```
      */
     const map: <A, B>(f: (a: A) => B) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
+    const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
     /**
      * Transforms each value in a record, also receiving the key.
      *
@@ -1390,6 +1423,16 @@ declare namespace Str {
          */
         float: (s: string) => Maybe<number>;
     };
+    /**
+     * Safely parses a JSON string, returning a `Result<SyntaxError, unknown>`.
+     *
+     * @example
+     * ```ts
+     * Str.parseJson('{"a": 1}'); // Ok({ a: 1 })
+     * Str.parseJson('invalid');  // Err(SyntaxError)
+     * ```
+     */
+    const parseJson: (s: string) => Result<SyntaxError, unknown>;
 }
 
 /**