@nlozgachev/pipelined 0.18.0 → 0.20.0

package/dist/index.js

@@ -245,8 +245,7 @@ var on = (f, g) => (a, b) => f(g(a), g(b));
 
 // src/Composition/pipe.ts
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
-  const len = arguments.length;
-  switch (len) {
+  switch (arguments.length) {
     case 1:
       return a;
     case 2:
@@ -574,77 +573,99 @@ var RemoteData;
 })(RemoteData || (RemoteData = {}));
 
 // src/Core/Task.ts
-var toPromise = (task) => Deferred.toPromise(task());
+var toPromise = (task, signal) => Deferred.toPromise(task(signal));
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
-  Task2.from = (f) => () => Deferred.fromPromise(f());
-  Task2.map = (f) => (data) => (0, Task2.from)(() => toPromise(data).then(f));
-  Task2.chain = (f) => (data) => (0, Task2.from)(() => toPromise(data).then((a) => toPromise(f(a))));
+  Task2.from = (f) => (signal) => Deferred.fromPromise(f(signal));
+  Task2.map = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then(f));
+  Task2.chain = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
   Task2.ap = (arg) => (data) => (0, Task2.from)(
-    () => Promise.all([
-      toPromise(data),
-      toPromise(arg)
+    (signal) => Promise.all([
+      toPromise(data, signal),
+      toPromise(arg, signal)
     ]).then(([f, a]) => f(a))
   );
   Task2.tap = (f) => (data) => (0, Task2.from)(
-    () => toPromise(data).then((a) => {
+    (signal) => toPromise(data, signal).then((a) => {
       f(a);
       return a;
     })
   );
   Task2.all = (tasks) => (0, Task2.from)(
-    () => Promise.all(tasks.map((t) => toPromise(t)))
+    (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
   Task2.delay = (ms) => (data) => (0, Task2.from)(
-    () => new Promise(
+    (signal) => new Promise(
       (resolve2) => setTimeout(
-        () => toPromise(data).then(resolve2),
+        () => toPromise(data, signal).then(resolve2),
         ms
       )
     )
   );
-  Task2.repeat = (options) => (task) => (0, Task2.from)(() => {
+  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 run = (left) => toPromise(task).then((a) => {
+    const run = (left) => toPromise(task, signal).then((a) => {
       results.push(a);
       if (left <= 1) return results;
       return wait().then(() => run(left - 1));
     });
     return run(times);
   });
-  Task2.repeatUntil = (options) => (task) => (0, Task2.from)(() => {
+  Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms } = options;
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = () => toPromise(task).then((a) => {
+    const run = () => toPromise(task, signal).then((a) => {
       if (predicate(a)) return a;
       return wait().then(run);
     });
     return run();
   });
-  Task2.race = (tasks) => (0, Task2.from)(() => Promise.race(tasks.map(toPromise)));
-  Task2.sequential = (tasks) => (0, Task2.from)(async () => {
+  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) {
-      results.push(await toPromise(task));
+      results.push(await toPromise(task, signal));
     }
     return results;
   });
-  Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)(() => {
+  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;
     return Promise.race([
-      toPromise(task).then((a) => {
+      toPromise(task, controller.signal).then((a) => {
         clearTimeout(timerId);
+        outerSignal?.removeEventListener("abort", onOuterAbort);
         return Result.ok(a);
       }),
       new Promise((resolve2) => {
-        timerId = setTimeout(() => resolve2(Result.err(onTimeout())), ms);
+        timerId = setTimeout(() => {
+          controller.abort();
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          resolve2(Result.err(onTimeout()));
+        }, ms);
       })
     ]);
   });
+  Task2.abortable = (factory) => {
+    const controller = new AbortController();
+    const task = (outerSignal) => {
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          controller.abort(outerSignal.reason);
+        } else {
+          outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
+        }
+      }
+      return Deferred.fromPromise(factory(controller.signal));
+    };
+    return { task, abort: () => controller.abort() };
+  };
 })(Task || (Task = {}));
 
 // src/Core/Resource.ts
@@ -739,12 +760,23 @@ var TaskMaybe;
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
+var cancellableWait = (ms, signal) => {
+  if (ms <= 0) return Promise.resolve();
+  if (!signal) return new Promise((r) => setTimeout(r, ms));
+  return new Promise((resolve) => {
+    const id = setTimeout(resolve, ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(id);
+      resolve();
+    }, { once: true });
+  });
+};
 var TaskResult;
 ((TaskResult2) => {
   TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
   TaskResult2.err = (error) => Task.resolve(Result.err(error));
   TaskResult2.tryCatch = (f, onError) => Task.from(
-    () => f().then(Result.ok).catch((e) => Result.err(onError(e)))
+    (signal) => f(signal).then(Result.ok).catch((e) => Result.err(onError(e)))
   );
   TaskResult2.map = (f) => (data) => Task.map(Result.map(f))(data);
   TaskResult2.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
@@ -758,43 +790,75 @@ var TaskResult;
   )(data);
   TaskResult2.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
   TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
-  TaskResult2.retry = (options) => (data) => Task.from(() => {
+  TaskResult2.retry = (options) => (data) => Task.from((signal) => {
     const { attempts, backoff, when: shouldRetry } = options;
     const getDelay = (n) => backoff === void 0 ? 0 : typeof backoff === "function" ? backoff(n) : backoff;
-    const run = (left) => Deferred.toPromise(data()).then((result) => {
+    const run = (left) => Deferred.toPromise(data(signal)).then((result) => {
       if (Result.isOk(result)) return result;
       if (left <= 1) return result;
       if (shouldRetry !== void 0 && !shouldRetry(result.error)) {
         return result;
       }
+      if (signal?.aborted) return result;
       const ms = getDelay(attempts - left + 1);
-      return (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve()).then(() => run(left - 1));
+      return cancellableWait(ms, signal).then(() => {
+        if (signal?.aborted) return result;
+        return run(left - 1);
+      });
     });
     return run(attempts);
   });
-  TaskResult2.pollUntil = (options) => (task) => Task.from(() => {
+  TaskResult2.pollUntil = (options) => (task) => Task.from((signal) => {
     const { when: predicate, delay } = options;
     const getDelay = (attempt) => delay === void 0 ? 0 : typeof delay === "function" ? delay(attempt) : delay;
-    const run = (attempt) => Deferred.toPromise(task()).then((result) => {
+    const run = (attempt) => Deferred.toPromise(task(signal)).then((result) => {
       if (Result.isErr(result)) return result;
       if (predicate(result.value)) return result;
+      if (signal?.aborted) return result;
       const ms = getDelay(attempt);
-      return (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve()).then(() => run(attempt + 1));
+      return cancellableWait(ms, signal).then(() => {
+        if (signal?.aborted) return result;
+        return run(attempt + 1);
+      });
     });
     return run(1);
   });
-  TaskResult2.timeout = (ms, onTimeout) => (data) => Task.from(() => {
+  TaskResult2.timeout = (ms, onTimeout) => (data) => Task.from((outerSignal) => {
+    const controller = new AbortController();
+    const onOuterAbort = () => controller.abort();
+    outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
     let timerId;
     return Promise.race([
-      Deferred.toPromise(data()).then((result) => {
+      Deferred.toPromise(data(controller.signal)).then((result) => {
         clearTimeout(timerId);
+        outerSignal?.removeEventListener("abort", onOuterAbort);
         return result;
       }),
       new Promise((resolve) => {
-        timerId = setTimeout(() => resolve(Result.err(onTimeout())), ms);
+        timerId = setTimeout(() => {
+          controller.abort();
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          resolve(Result.err(onTimeout()));
+        }, ms);
       })
     ]);
   });
+  TaskResult2.abortable = (factory, onError) => {
+    const controller = new AbortController();
+    const task = (outerSignal) => {
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          controller.abort(outerSignal.reason);
+        } else {
+          outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
+        }
+      }
+      return Deferred.fromPromise(
+        factory(controller.signal).then(Result.ok).catch((e) => Result.err(onError(e)))
+      );
+    };
+    return { task, abort: () => controller.abort() };
+  };
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts

package/dist/index.mjs

@@ -26,7 +26,7 @@ import {
   uncurry,
   uncurry3,
   uncurry4
-} from "./chunk-5HMYR4XB.mjs";
+} from "./chunk-NRF2FVPZ.mjs";
 import {
   Lens,
   Logged,
@@ -43,7 +43,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-UWGFO7BH.mjs";
+} from "./chunk-7COGDULU.mjs";
 import {
   Arr,
   Dict,
@@ -51,13 +51,13 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-B3YNH6GZ.mjs";
+} from "./chunk-AC7RQXWC.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-EAR4TIGH.mjs";
+} from "./chunk-RUDOUVQR.mjs";
 import {
   Brand
 } from "./chunk-BYWKZLHM.mjs";

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-DBW4nOZR.mjs';
+import { M as Maybe, R as Result, T as Task } from './Task-JOnNAaPq.mjs';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 
 /**

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-DUdIQm-Q.js';
+import { M as Maybe, R as Result, T as Task } from './Task-BAT6Z6b9.js';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
 
 /**

package/dist/utils.js

@@ -100,77 +100,99 @@ var Maybe;
 })(Maybe || (Maybe = {}));
 
 // src/Core/Task.ts
-var toPromise = (task) => Deferred.toPromise(task());
+var toPromise = (task, signal) => Deferred.toPromise(task(signal));
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
-  Task2.from = (f) => () => Deferred.fromPromise(f());
-  Task2.map = (f) => (data) => (0, Task2.from)(() => toPromise(data).then(f));
-  Task2.chain = (f) => (data) => (0, Task2.from)(() => toPromise(data).then((a) => toPromise(f(a))));
+  Task2.from = (f) => (signal) => Deferred.fromPromise(f(signal));
+  Task2.map = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then(f));
+  Task2.chain = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
   Task2.ap = (arg) => (data) => (0, Task2.from)(
-    () => Promise.all([
-      toPromise(data),
-      toPromise(arg)
+    (signal) => Promise.all([
+      toPromise(data, signal),
+      toPromise(arg, signal)
     ]).then(([f, a]) => f(a))
   );
   Task2.tap = (f) => (data) => (0, Task2.from)(
-    () => toPromise(data).then((a) => {
+    (signal) => toPromise(data, signal).then((a) => {
       f(a);
       return a;
     })
   );
   Task2.all = (tasks) => (0, Task2.from)(
-    () => Promise.all(tasks.map((t) => toPromise(t)))
+    (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
   Task2.delay = (ms) => (data) => (0, Task2.from)(
-    () => new Promise(
+    (signal) => new Promise(
       (resolve2) => setTimeout(
-        () => toPromise(data).then(resolve2),
+        () => toPromise(data, signal).then(resolve2),
         ms
       )
     )
   );
-  Task2.repeat = (options) => (task) => (0, Task2.from)(() => {
+  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 run = (left) => toPromise(task).then((a) => {
+    const run = (left) => toPromise(task, signal).then((a) => {
       results.push(a);
       if (left <= 1) return results;
       return wait().then(() => run(left - 1));
     });
     return run(times);
   });
-  Task2.repeatUntil = (options) => (task) => (0, Task2.from)(() => {
+  Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms } = options;
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = () => toPromise(task).then((a) => {
+    const run = () => toPromise(task, signal).then((a) => {
       if (predicate(a)) return a;
       return wait().then(run);
     });
     return run();
   });
-  Task2.race = (tasks) => (0, Task2.from)(() => Promise.race(tasks.map(toPromise)));
-  Task2.sequential = (tasks) => (0, Task2.from)(async () => {
+  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) {
-      results.push(await toPromise(task));
+      results.push(await toPromise(task, signal));
     }
     return results;
   });
-  Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)(() => {
+  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;
     return Promise.race([
-      toPromise(task).then((a) => {
+      toPromise(task, controller.signal).then((a) => {
         clearTimeout(timerId);
+        outerSignal?.removeEventListener("abort", onOuterAbort);
         return Result.ok(a);
       }),
       new Promise((resolve2) => {
-        timerId = setTimeout(() => resolve2(Result.err(onTimeout())), ms);
+        timerId = setTimeout(() => {
+          controller.abort();
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          resolve2(Result.err(onTimeout()));
+        }, ms);
       })
     ]);
   });
+  Task2.abortable = (factory) => {
+    const controller = new AbortController();
+    const task = (outerSignal) => {
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          controller.abort(outerSignal.reason);
+        } else {
+          outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
+        }
+      }
+      return Deferred.fromPromise(factory(controller.signal));
+    };
+    return { task, abort: () => controller.abort() };
+  };
 })(Task || (Task = {}));
 
 // src/Types/NonEmptyList.ts

package/dist/utils.mjs

@@ -5,8 +5,8 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-B3YNH6GZ.mjs";
-import "./chunk-EAR4TIGH.mjs";
+} from "./chunk-AC7RQXWC.mjs";
+import "./chunk-RUDOUVQR.mjs";
 import "./chunk-DBIC62UV.mjs";
 export {
   Arr,

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@nlozgachev/pipelined",
-	"version": "0.18.0",
-	"description": "Simple functional programming toolkit for TypeScript",
+	"version": "0.20.0",
+	"description": "Opinionated functional abstractions for TypeScript",
 	"license": "BSD-3-Clause",
 	"homepage": "https://pipelined.lozgachev.dev",
 	"repository": {