@nlozgachev/pipelined 0.31.0 → 0.33.0

package/dist/{chunk-SDGDJ7CU.mjs → chunk-GSTKY7MF.mjs}

@@ -1,12 +1,6 @@
-// src/Core/Deferred.ts
-var Deferred;
-((Deferred2) => {
-  Deferred2.fromPromise = (p) => (
-    // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
-    { then: ((f) => p.then(f)) }
-  );
-  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
-})(Deferred || (Deferred = {}));
+import {
+  Duration
+} from "./chunk-VWVPHDZO.mjs";
 
 // src/Core/Maybe.ts
 var _none = { kind: "None" };
@@ -65,14 +59,34 @@ var Result;
     return data;
   };
   Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.error)(onFalse(a));
+  Result2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result2.error)(onNull()) : (0, Result2.ok)(value);
+  Result2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result2.error)(onNone()) : (0, Result2.ok)(maybe.value);
+  Result2.fromThrowable = (f, onError) => (...args) => {
+    try {
+      return (0, Result2.ok)(f(...args));
+    } catch (e) {
+      return (0, Result2.error)(onError(e));
+    }
+  };
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
   Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isError)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isError)(data) ? data : arg;
 })(Result || (Result = {}));
 
+// src/Core/Deferred.ts
+var Deferred;
+((Deferred2) => {
+  Deferred2.fromPromise = (p) => (
+    // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
+    { then: ((f) => p.then(f)) }
+  );
+  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
+})(Deferred || (Deferred = {}));
+
 // src/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
+var getMs = (ms) => typeof ms === "number" ? ms : Duration.toMilliseconds(ms);
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
@@ -96,60 +110,169 @@ 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));
+      }, getMs(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();
+        }, getMs(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();
+        }, getMs(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.race = (tasks) => {
+    if (tasks.length === 0) {
+      return () => Deferred.fromPromise(new Promise(() => {
+      }));
+    }
+    return (0, Task2.from)((outerSignal) => {
+      const controllers = tasks.map(() => new AbortController());
+      const onOuterAbort = () => {
+        for (const ctrl of controllers) ctrl.abort();
+      };
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          onOuterAbort();
+        } else {
+          outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+        }
+      }
+      const promises = tasks.map((task, idx) => {
+        const ctrl = controllers[idx];
+        return toPromise(task, ctrl.signal).then((result) => {
+          for (let i = 0; i < controllers.length; i++) {
+            if (i !== idx) {
+              controllers[i].abort();
+            }
+          }
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          return result;
+        });
+      });
+      return Promise.race(promises);
+    });
+  };
+  Task2.sequence = (tasks) => (0, Task2.from)((signal) => Promise.all(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);
+        }, getMs(ms));
       })
     ]);
   });
@@ -175,8 +298,8 @@ var Task;
 })(Task || (Task = {}));
 
 export {
-  Deferred,
   Result,
   Maybe,
+  Deferred,
   Task
 };

package/dist/chunk-VWVPHDZO.mjs

@@ -0,0 +1,29 @@
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  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 = {}));
+
+export {
+  Brand,
+  Duration
+};

package/dist/{chunk-FWYOEWJ2.mjs → chunk-W53ZYTLX.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-SDGDJ7CU.mjs";
+} from "./chunk-GSTKY7MF.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";
@@ -65,6 +65,40 @@ var Arr;
     }
     return [pass, fail];
   };
+  Arr2.compact = (data) => {
+    const result = [];
+    for (const item of data) {
+      if (item.kind === "Some") {
+        result.push(item.value);
+      }
+    }
+    return result;
+  };
+  Arr2.separate = (data) => {
+    const errors = [];
+    const successes = [];
+    for (const item of data) {
+      if (item.kind === "Ok") {
+        successes.push(item.value);
+      } else {
+        errors.push(item.error);
+      }
+    }
+    return [errors, successes];
+  };
+  Arr2.partitionMap = (f) => (data) => {
+    const errors = [];
+    const successes = [];
+    for (const item of data) {
+      const mapped = f(item);
+      if (mapped.kind === "Ok") {
+        successes.push(mapped.value);
+      } else {
+        errors.push(mapped.error);
+      }
+    }
+    return [errors, successes];
+  };
   Arr2.groupBy = (f) => (data) => {
     const result = {};
     for (const a of data) {
@@ -89,11 +123,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);
@@ -126,7 +174,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 = [];
@@ -365,8 +429,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);
@@ -382,6 +446,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
@@ -505,6 +591,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;
@@ -543,6 +630,13 @@ var Str;
       return isNaN(n) ? Maybe.none() : Maybe.some(n);
     }
   };
+  Str2.parseJson = (s) => {
+    try {
+      return Result.ok(JSON.parse(s));
+    } catch (e) {
+      return Result.error(e);
+    }
+  };
 })(Str || (Str = {}));
 
 // src/Utils/Uniq.ts