@nlozgachev/pipelined 0.31.0 → 0.32.0

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-BDcKwFAj.mjs';
+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';
 
 /**
@@ -173,8 +173,26 @@ declare namespace Arr {
      * ```
      */
     const uniqBy: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly A[];
+    /**
+     * Removes duplicate elements using a custom equality check.
+     * Preserves the order of first occurrences. Complements `uniq` (reference equality)
+     * and `uniqBy` (key extraction).
+     *
+     * @example
+     * ```ts
+     * type Point = { x: number; y: number };
+     * const eqPoint: Equality<Point> = (a, b) => a.x === b.x && a.y === b.y;
+     *
+     * pipe(
+     *   [{ x: 1, y: 1 }, { x: 2, y: 2 }, { x: 1, y: 1 }],
+     *   Arr.uniqWith(eqPoint),
+     * ); // [{ x: 1, y: 1 }, { x: 2, y: 2 }]
+     * ```
+     */
+    const uniqWith: <A>(eq: Equality<A>) => (data: readonly A[]) => readonly A[];
     /**
      * Sorts an array using a comparison function. Returns a new array.
+     * To sort with a typed `Ordering<A>`, prefer `Arr.sortWith`.
      *
      * @example
      * ```ts
@@ -182,6 +200,19 @@ declare namespace Arr {
      * ```
      */
     const sortBy: <A>(compare: (a: A, b: A) => number) => (data: readonly A[]) => readonly A[];
+    /**
+     * Sorts an array using an `Ordering<A>`. Returns a new array without mutating the original.
+     * Use this over `sortBy` when you have a typed `Ordering<A>` from the `Ordering` module.
+     *
+     * @example
+     * ```ts
+     * pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]
+     *
+     * const byPrice = pipe(Ordering.number, Ordering.by((p: Product) => p.price));
+     * pipe(products, Arr.sortWith(byPrice));
+     * ```
+     */
+    const sortWith: <A>(ord: Ordering<A>) => (data: readonly A[]) => readonly A[];
     /**
      * Pairs up elements from two arrays. Stops at the shorter array.
      *
@@ -945,6 +976,46 @@ declare namespace Num {
      * ```
      */
     const remainder: (divisor: number) => (n: number) => Maybe<number>;
+    /**
+     * Computes the sum of a list of numbers. Returns `0` if the list is empty.
+     *
+     * @example
+     * ```ts
+     * Num.sum([1, 2, 3]); // 6
+     * Num.sum([]);        // 0
+     * ```
+     */
+    const sum: (ns: readonly number[]) => number;
+    /**
+     * Computes the mean of a list of numbers. Returns `None` if the list is empty.
+     *
+     * @example
+     * ```ts
+     * Num.mean([1, 2, 3]); // Some(2)
+     * Num.mean([]);        // None
+     * ```
+     */
+    const mean: (ns: readonly number[]) => Maybe<number>;
+    /**
+     * Computes the minimum of a list of numbers. Returns `None` if the list is empty.
+     *
+     * @example
+     * ```ts
+     * Num.min([5, 1, 3]); // Some(1)
+     * Num.min([]);        // None
+     * ```
+     */
+    const min: (ns: readonly number[]) => Maybe<number>;
+    /**
+     * Computes the maximum of a list of numbers. Returns `None` if the list is empty.
+     *
+     * @example
+     * ```ts
+     * Num.max([1, 5, 3]); // Some(5)
+     * Num.max([]);        // None
+     * ```
+     */
+    const max: (ns: readonly number[]) => Maybe<number>;
 }
 
 /**
@@ -1204,6 +1275,15 @@ declare namespace Str {
      * ```
      */
     const toLowerCase: (s: string) => string;
+    /**
+     * Converts the first character of a string to uppercase.
+     *
+     * @example
+     * ```ts
+     * pipe("hello", Str.capitalize); // "Hello"
+     * ```
+     */
+    const capitalize: (s: string) => string;
     /**
      * Splits a string into lines, normalising `\r\n` and `\r` line endings.
      *

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-CnF22Q2o.js';
+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';
 
 /**
@@ -173,8 +173,26 @@ declare namespace Arr {
      * ```
      */
     const uniqBy: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly A[];
+    /**
+     * Removes duplicate elements using a custom equality check.
+     * Preserves the order of first occurrences. Complements `uniq` (reference equality)
+     * and `uniqBy` (key extraction).
+     *
+     * @example
+     * ```ts
+     * type Point = { x: number; y: number };
+     * const eqPoint: Equality<Point> = (a, b) => a.x === b.x && a.y === b.y;
+     *
+     * pipe(
+     *   [{ x: 1, y: 1 }, { x: 2, y: 2 }, { x: 1, y: 1 }],
+     *   Arr.uniqWith(eqPoint),
+     * ); // [{ x: 1, y: 1 }, { x: 2, y: 2 }]
+     * ```
+     */
+    const uniqWith: <A>(eq: Equality<A>) => (data: readonly A[]) => readonly A[];
     /**
      * Sorts an array using a comparison function. Returns a new array.
+     * To sort with a typed `Ordering<A>`, prefer `Arr.sortWith`.
      *
      * @example
      * ```ts
@@ -182,6 +200,19 @@ declare namespace Arr {
      * ```
      */
     const sortBy: <A>(compare: (a: A, b: A) => number) => (data: readonly A[]) => readonly A[];
+    /**
+     * Sorts an array using an `Ordering<A>`. Returns a new array without mutating the original.
+     * Use this over `sortBy` when you have a typed `Ordering<A>` from the `Ordering` module.
+     *
+     * @example
+     * ```ts
+     * pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]
+     *
+     * const byPrice = pipe(Ordering.number, Ordering.by((p: Product) => p.price));
+     * pipe(products, Arr.sortWith(byPrice));
+     * ```
+     */
+    const sortWith: <A>(ord: Ordering<A>) => (data: readonly A[]) => readonly A[];
     /**
      * Pairs up elements from two arrays. Stops at the shorter array.
      *
@@ -945,6 +976,46 @@ declare namespace Num {
      * ```
      */
     const remainder: (divisor: number) => (n: number) => Maybe<number>;
+    /**
+     * Computes the sum of a list of numbers. Returns `0` if the list is empty.
+     *
+     * @example
+     * ```ts
+     * Num.sum([1, 2, 3]); // 6
+     * Num.sum([]);        // 0
+     * ```
+     */
+    const sum: (ns: readonly number[]) => number;
+    /**
+     * Computes the mean of a list of numbers. Returns `None` if the list is empty.
+     *
+     * @example
+     * ```ts
+     * Num.mean([1, 2, 3]); // Some(2)
+     * Num.mean([]);        // None
+     * ```
+     */
+    const mean: (ns: readonly number[]) => Maybe<number>;
+    /**
+     * Computes the minimum of a list of numbers. Returns `None` if the list is empty.
+     *
+     * @example
+     * ```ts
+     * Num.min([5, 1, 3]); // Some(1)
+     * Num.min([]);        // None
+     * ```
+     */
+    const min: (ns: readonly number[]) => Maybe<number>;
+    /**
+     * Computes the maximum of a list of numbers. Returns `None` if the list is empty.
+     *
+     * @example
+     * ```ts
+     * Num.max([1, 5, 3]); // Some(5)
+     * Num.max([]);        // None
+     * ```
+     */
+    const max: (ns: readonly number[]) => Maybe<number>;
 }
 
 /**
@@ -1204,6 +1275,15 @@ declare namespace Str {
      * ```
      */
     const toLowerCase: (s: string) => string;
+    /**
+     * Converts the first character of a string to uppercase.
+     *
+     * @example
+     * ```ts
+     * pipe("hello", Str.capitalize); // "Hello"
+     * ```
+     */
+    const capitalize: (s: string) => string;
     /**
      * Splits a string into lines, normalising `\r\n` and `\r` line endings.
      *

package/dist/utils.js

@@ -127,58 +127,135 @@ var Task;
     (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
   Task2.delay = (ms) => (data) => (0, Task2.from)(
-    (signal) => new Promise(
-      (resolve2) => setTimeout(
-        () => toPromise(data, signal).then(resolve2),
-        ms
-      )
-    )
+    (signal) => new Promise((resolve2) => {
+      let timerId = void 0;
+      const onAbort = () => {
+        if (timerId !== void 0) {
+          clearTimeout(timerId);
+        }
+        resolve2(toPromise(data, signal));
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return resolve2(toPromise(data, signal));
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve2(toPromise(data, signal));
+      }, ms);
+    })
   );
   Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
     const { times, delay: ms } = options;
     if (times <= 0) return Promise.resolve([]);
     const results = [];
-    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run2 = (left) => toPromise(task, signal).then((a) => {
-      results.push(a);
-      if (left <= 1) return results;
-      return wait().then(() => run2(left - 1));
-    });
+    const wait = () => {
+      if (signal?.aborted) return Promise.resolve();
+      return new Promise((r) => {
+        let timerId = void 0;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, ms || 0);
+      });
+    };
+    const run2 = (left) => {
+      if (signal?.aborted) {
+        return Promise.resolve(results);
+      }
+      return toPromise(task, signal).then((a) => {
+        results.push(a);
+        if (left <= 1 || signal?.aborted) return results;
+        return wait().then(() => run2(left - 1));
+      });
+    };
     return run2(times);
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms, maxAttempts } = options;
-    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run2 = (attempt) => toPromise(task, signal).then((a) => {
-      if (predicate(a)) return a;
-      if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
-      return wait().then(() => run2(attempt + 1));
-    });
+    const wait = () => {
+      if (signal?.aborted) return Promise.resolve();
+      return new Promise((r) => {
+        let timerId = void 0;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, ms || 0);
+      });
+    };
+    const run2 = (attempt, lastValue) => {
+      if (signal?.aborted && lastValue !== void 0) {
+        return Promise.resolve(lastValue);
+      }
+      return toPromise(task, signal).then((a) => {
+        if (predicate(a)) return a;
+        if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
+        if (signal?.aborted) return a;
+        return wait().then(() => run2(attempt + 1, a));
+      });
+    };
     return run2(1);
   });
   Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
     const results = [];
     for (const task of tasks) {
+      if (signal?.aborted) {
+        break;
+      }
       results.push(await toPromise(task, signal));
     }
     return results;
   });
   Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
     const controller = new AbortController();
-    const onOuterAbort = () => controller.abort();
-    outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
     let timerId;
+    const cleanUp = () => {
+      if (timerId !== void 0) {
+        clearTimeout(timerId);
+      }
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+    };
+    const onOuterAbort = () => {
+      cleanUp();
+      controller.abort();
+    };
+    if (outerSignal) {
+      if (outerSignal.aborted) {
+        controller.abort();
+      } else {
+        outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+      }
+    }
     return Promise.race([
       toPromise(task, controller.signal).then((a) => {
-        clearTimeout(timerId);
-        outerSignal?.removeEventListener("abort", onOuterAbort);
+        cleanUp();
         return Result.ok(a);
       }),
       new Promise((resolve2) => {
         timerId = setTimeout(() => {
           controller.abort();
-          outerSignal?.removeEventListener("abort", onOuterAbort);
+          cleanUp();
           resolve2(Result.error(onTimeout()));
         }, ms);
       })
@@ -289,11 +366,25 @@ var Arr;
     }
     return result;
   };
+  Arr2.uniqWith = (eq) => (data) => {
+    const result = [];
+    for (const a of data) {
+      if (!result.some((x) => eq(x, a))) {
+        result.push(a);
+      }
+    }
+    return result;
+  };
   Arr2.sortBy = (compare) => (data) => {
     const arr = data;
     if (typeof arr.toSorted === "function") return arr.toSorted(compare);
     return [...data].sort(compare);
   };
+  Arr2.sortWith = (ord) => (data) => {
+    const arr = data;
+    if (typeof arr.toSorted === "function") return arr.toSorted(ord);
+    return [...data].sort(ord);
+  };
   Arr2.zip = (other) => (data) => {
     const len = Math.min(data.length, other.length);
     const result = new Array(len);
@@ -326,7 +417,23 @@ var Arr;
     }
     return result;
   };
-  Arr2.flatten = (data) => [].concat(...data);
+  Arr2.flatten = (data) => {
+    let totalLen = 0;
+    const outerLen = data.length;
+    for (let i = 0; i < outerLen; i++) {
+      totalLen += data[i].length;
+    }
+    const result = new Array(totalLen);
+    let idx = 0;
+    for (let i = 0; i < outerLen; i++) {
+      const chunk = data[i];
+      const innerLen = chunk.length;
+      for (let j = 0; j < innerLen; j++) {
+        result[idx++] = chunk[j];
+      }
+    }
+    return result;
+  };
   Arr2.flatMap = (f) => (data) => {
     const n = data.length;
     const result = [];
@@ -565,8 +672,8 @@ var Num;
     }
     return result;
   };
-  Num2.clamp = (min, max) => (n) => Math.min(Math.max(n, min), max);
-  Num2.between = (min, max) => (n) => n >= min && n <= max;
+  Num2.clamp = (min2, max2) => (n) => Math.min(Math.max(n, min2), max2);
+  Num2.between = (min2, max2) => (n) => n >= min2 && n <= max2;
   Num2.parse = (s) => {
     if (s.trim() === "") return Maybe.none();
     const n = Number(s);
@@ -582,6 +689,28 @@ var Num;
   Num2.floor = (n) => Math.floor(n);
   Num2.ceil = (n) => Math.ceil(n);
   Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.none() : Maybe.some(n % divisor);
+  Num2.sum = (ns) => {
+    let result = 0;
+    for (let i = 0; i < ns.length; i++) result += ns[i];
+    return result;
+  };
+  Num2.mean = (ns) => ns.length === 0 ? Maybe.none() : Maybe.some((0, Num2.sum)(ns) / ns.length);
+  Num2.min = (ns) => {
+    if (ns.length === 0) return Maybe.none();
+    let [result] = ns;
+    for (let i = 1; i < ns.length; i++) {
+      if (ns[i] < result) result = ns[i];
+    }
+    return Maybe.some(result);
+  };
+  Num2.max = (ns) => {
+    if (ns.length === 0) return Maybe.none();
+    let [result] = ns;
+    for (let i = 1; i < ns.length; i++) {
+      if (ns[i] > result) result = ns[i];
+    }
+    return Maybe.some(result);
+  };
 })(Num || (Num = {}));
 
 // src/Utils/Rec.ts
@@ -705,6 +834,7 @@ var Str;
   Str2.endsWith = (suffix) => (s) => s.endsWith(suffix);
   Str2.toUpperCase = (s) => s.toUpperCase();
   Str2.toLowerCase = (s) => s.toLowerCase();
+  Str2.capitalize = (s) => s.length === 0 ? "" : s.charAt(0).toUpperCase() + s.slice(1);
   Str2.lines = (s) => s.split(/\r?\n|\r/);
   Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
   Str2.isEmpty = (s) => s.length === 0;

package/dist/utils.mjs

@@ -5,8 +5,8 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-FWYOEWJ2.mjs";
-import "./chunk-SDGDJ7CU.mjs";
+} from "./chunk-EHQFUWZW.mjs";
+import "./chunk-TK5ZCGP2.mjs";
 import "./chunk-DBIC62UV.mjs";
 export {
   Arr,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nlozgachev/pipelined",
-	"version": "0.31.0",
+	"version": "0.32.0",
 	"description": "Opinionated functional abstractions for TypeScript",
 	"license": "BSD-3-Clause",
 	"homepage": "https://pipelined.lozgachev.dev",