@nlozgachev/pipelined 0.19.0 → 0.20.0

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.19.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": {