@nlozgachev/pipelined 0.53.0 → 0.55.0

package/dist/{chunk-XFE3SQEE.mjs → chunk-MFJXL6J2.js}

@@ -1,6 +1,6 @@
 import {
   Duration
-} from "./chunk-DENXUTKL.mjs";
+} from "./chunk-OIIOGDHK.js";
 
 // src/Core/Combinable.ts
 var Combinable;
@@ -1575,8 +1575,8 @@ var Resource;
       release
     });
   })(from = Resource2.from || (Resource2.from = {}));
-  Resource2.use = (f) => (resource) => Task.from.Promise(
-    (signal) => Deferred.to.Promise(resource.acquire(signal)).then(async (acquired) => {
+  Resource2.use = (f) => (resource) => (signal) => Deferred.from.Promise(
+    Deferred.to.Promise(resource.acquire(signal)).then(async (acquired) => {
       if (Result.is.err(acquired)) {
         return acquired;
       }
@@ -1590,8 +1590,8 @@ var Resource;
     })
   );
   Resource2.combine = (resourceA, resourceB) => ({
-    acquire: Task.from.Promise(
-      (signal) => Deferred.to.Promise(resourceA.acquire(signal)).then(async (acquiredA) => {
+    acquire: (signal) => Deferred.from.Promise(
+      Deferred.to.Promise(resourceA.acquire(signal)).then(async (acquiredA) => {
         if (Result.is.err(acquiredA)) {
           return acquiredA;
         }
@@ -1604,8 +1604,8 @@ var Resource;
         return Result.make.ok([a, acquiredB.value]);
       })
     ),
-    release: ([a, b]) => Task.from.Promise(
-      (signal) => Deferred.to.Promise(resourceB.release(b)(signal)).then(() => Deferred.to.Promise(resourceA.release(a)(signal)))
+    release: ([a, b]) => (signal) => Deferred.from.Promise(
+      Deferred.to.Promise(resourceB.release(b)(signal)).then(() => Deferred.to.Promise(resourceA.release(a)(signal)))
     )
   });
 })(Resource || (Resource = {}));
@@ -1653,13 +1653,6 @@ var Result;
     from2.Predicate = (pred, onFalse) => (a) => pred(a) ? make.ok(a) : make.err(onFalse(a));
     from2.nullable = (onNull) => (value) => value === null || value === void 0 ? make.err(onNull()) : make.ok(value);
     from2.Maybe = (onNone) => (maybe) => Maybe.is.none(maybe) ? make.err(onNone()) : make.ok(maybe.value);
-    from2.throwable = (f, options) => (...args) => {
-      try {
-        return make.ok(f(...args));
-      } catch (error) {
-        return make.err(options.onError(error));
-      }
-    };
     from2.Validation = (combineErrors) => (val) => Validation.is.passed(val) ? make.ok(val.value) : make.err(combineErrors(val.errors));
   })(from = Result4.from || (Result4.from = {}));
   Result4.recover = (fallback) => (data) => is.ok(data) ? data : fallback(data.error);
@@ -1879,15 +1872,13 @@ var TaskMaybe;
     from2.Result = (result) => Task.resolve(Result.to.Maybe(result));
     from2.Task = (task) => Task.map(Maybe.make.some)(task);
   })(from = TaskMaybe2.from || (TaskMaybe2.from = {}));
-  TaskMaybe2.tryCatch = (f) => Task.from.Promise(
-    (signal) => Promise.resolve(f(signal)).then(Maybe.make.some).catch(() => Maybe.make.none())
-  );
+  TaskMaybe2.tryCatch = (f) => (signal) => Deferred.from.Promise(Promise.resolve(f(signal)).then(Maybe.make.some).catch(() => Maybe.make.none()));
   TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
   TaskMaybe2.chain = (f) => (data) => Task.chain(
     (option) => Maybe.is.some(option) ? f(option.value) : Task.resolve(Maybe.make.none())
   )(data);
-  TaskMaybe2.ap = (arg) => (data) => Task.from.Promise(
-    (signal) => Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
+  TaskMaybe2.ap = (arg) => (data) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
       ([of_, oa]) => Maybe.ap(oa)(of_)
     )
   );
@@ -1907,7 +1898,7 @@ var TaskMaybe;
   TaskMaybe2.recover = (fallback) => (data) => Task.chain((maybe) => Maybe.is.none(maybe) ? fallback() : Task.resolve(maybe))(
     data
   );
-  TaskMaybe2.struct = (fields) => Task.from.Promise((signal) => {
+  TaskMaybe2.struct = (fields) => (signal) => Deferred.from.Promise((() => {
     const keys = Object.keys(fields);
     const promises = keys.map((key) => Deferred.to.Promise(fields[key](signal)));
     return Promise.all(promises).then((results) => {
@@ -1921,7 +1912,7 @@ var TaskMaybe;
       }
       return Maybe.make.some(record);
     });
-  });
+  })());
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
@@ -1939,16 +1930,15 @@ var TaskResult;
     from2.nullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.make.err(onNull()) : Result.make.ok(value));
     from2.Maybe = (onNone) => (maybe) => Task.resolve(Maybe.is.none(maybe) ? Result.make.err(onNone()) : Result.make.ok(maybe.value));
     from2.Result = (result) => Task.resolve(result);
-    from2.throwable = (f, options) => (...args) => Task.from.Promise(
-      () => f(...args).then(Result.make.ok).catch((error) => Result.make.err(options.onError(error)))
-    );
   })(from = TaskResult2.from || (TaskResult2.from = {}));
   let to;
   ((to2) => {
     to2.Maybe = (data) => Task.map(Result.to.Maybe)(data);
   })(to = TaskResult2.to || (TaskResult2.to = {}));
-  TaskResult2.tryCatch = (f, options) => Task.from.Promise(
-    (signal) => Promise.resolve(f(signal)).then(Result.make.ok).catch((error) => Result.make.err(options.onError(error)))
+  TaskResult2.tryCatch = (f, options) => (signal) => Deferred.from.Promise(
+    globalThis.Promise.resolve().then(async () => f(signal)).then(Result.make.ok).catch(
+      (error) => Result.make.err(options.onError(error))
+    )
   );
   TaskResult2.map = (f) => (data) => Task.map(Result.map(f))(data);
   TaskResult2.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
@@ -1963,8 +1953,8 @@ var TaskResult;
   TaskResult2.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
   TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
   TaskResult2.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
-  TaskResult2.ap = (arg) => (data) => Task.from.Promise(
-    (signal) => Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
+  TaskResult2.ap = (arg) => (data) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
       ([of_, oa]) => Result.ap(oa)(of_)
     )
   );
@@ -1973,7 +1963,7 @@ var TaskResult;
   TaskResult2.bind = (key, f) => (data) => (0, TaskResult2.chain)(
     (a) => (0, TaskResult2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
-  TaskResult2.struct = (fields) => Task.from.Promise((signal) => {
+  TaskResult2.struct = (fields) => (signal) => Deferred.from.Promise((() => {
     const keys = Object.keys(fields);
     const promises = keys.map((key) => Deferred.to.Promise(fields[key](signal)));
     return Promise.all(promises).then((results) => {
@@ -1987,8 +1977,8 @@ var TaskResult;
       }
       return Result.make.ok(record);
     });
-  });
-  TaskResult2.retry = (policy) => (task) => Task.from.Promise((signal) => {
+  })());
+  TaskResult2.retry = (policy) => (task) => (signal) => Deferred.from.Promise((() => {
     const { attempts } = policy;
     const wait = (duration) => new Promise((res) => {
       let timerId;
@@ -2015,11 +2005,11 @@ var TaskResult;
       return wait(delay).then(() => executeAttempt(attempt + 1));
     });
     return executeAttempt(1);
-  });
+  })());
   TaskResult2.memoize = (task) => Task.memoize(task);
-  TaskResult2.timeout = (options) => (task) => Task.from.Promise((signal) => {
-    const ms = Duration.to.milliseconds(options.duration);
-    return new Promise((resolve) => {
+  TaskResult2.timeout = (options) => (task) => (signal) => Deferred.from.Promise(
+    new Promise((resolve) => {
+      const ms = Duration.to.milliseconds(options.duration);
       let timerId;
       const onAbort = () => {
         clearTimeout(timerId);
@@ -2039,9 +2029,9 @@ var TaskResult;
         signal?.removeEventListener("abort", onAbort);
         resolve(res);
       });
-    });
-  });
-  TaskResult2.allSettled = (tasks) => Task.from.Promise((signal) => Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal)))));
+    })
+  );
+  TaskResult2.allSettled = (tasks) => (signal) => Deferred.from.Promise(Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal)))));
 })(TaskResult || (TaskResult = {}));
 
 // src/internal/InternalTypes.ts
@@ -2070,14 +2060,14 @@ var TaskValidation;
     );
     from2.Result = (result) => Task.resolve(Validation.from.Result(result));
   })(from = TaskValidation2.from || (TaskValidation2.from = {}));
-  TaskValidation2.tryCatch = (f, onError) => Task.from.Promise(
-    (signal) => Promise.resolve(f(signal)).then(Validation.make.passed).catch(
-      (error) => Validation.make.failed(onError(error))
+  TaskValidation2.tryCatch = (f, options) => (signal) => Deferred.from.Promise(
+    globalThis.Promise.resolve().then(async () => f(signal)).then(Validation.make.passed).catch(
+      (error) => Validation.make.failed(options.onError(error))
     )
   );
   TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
-  TaskValidation2.ap = (arg) => (data) => Task.from.Promise(
-    (signal) => Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
+  TaskValidation2.ap = (arg) => (data) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
       ([vf, va]) => Validation.ap(va)(vf)
     )
   );
@@ -2088,20 +2078,20 @@ var TaskValidation;
   TaskValidation2.recover = (fallback) => (data) => Task.chain(
     (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : fallback(validation.errors)
   )(data);
-  TaskValidation2.product = (first, second) => Task.from.Promise(
-    (signal) => Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
+  TaskValidation2.product = (first, second) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
       ([va, vb]) => Validation.product(va, vb)
     )
   );
-  TaskValidation2.productAll = (data) => Task.from.Promise(
-    (signal) => Promise.all(data.map((t) => Deferred.to.Promise(t(signal)))).then((results) => {
+  TaskValidation2.productAll = (data) => (signal) => Deferred.from.Promise(
+    Promise.all(data.map((t) => Deferred.to.Promise(t(signal)))).then((results) => {
       const [first, ...rest] = results;
       return Validation.productAll([first, ...rest]);
     })
   );
   TaskValidation2.mapError = (f) => (data) => Task.map(Validation.mapError(f))(data);
   TaskValidation2.tapError = (f) => (data) => Task.map(Validation.tapError(f))(data);
-  TaskValidation2.struct = (fields) => Task.from.Promise((signal) => {
+  TaskValidation2.struct = (fields) => (signal) => Deferred.from.Promise((() => {
     const keys = Object.keys(fields);
     const promises = keys.map((key) => Deferred.to.Promise(fields[key](signal)));
     return Promise.all(promises).then((results) => {
@@ -2117,33 +2107,34 @@ var TaskValidation;
       }
       return isNonEmptyArr(errors) ? Validation.make.failedAll(errors) : Validation.make.passed(record);
     });
-  });
+  })());
 })(TaskValidation || (TaskValidation = {}));
 
 // src/Core/Task.ts
 var toPromise = (task, signal) => Deferred.to.Promise(task(signal));
+var fromPromise = (f) => (signal) => Deferred.from.Promise(f(signal));
 var getMs2 = (duration) => Duration.to.milliseconds(duration);
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.from.Promise(globalThis.Promise.resolve(value));
   let from;
   ((from2) => {
-    from2.Promise = (f) => (signal) => Deferred.from.Promise(f(signal));
     from2.sync = (f) => () => Deferred.from.Promise(globalThis.Promise.resolve(f()));
   })(from = Task2.from || (Task2.from = {}));
-  Task2.map = (f) => (data) => from.Promise((signal) => toPromise(data, signal).then(f));
-  Task2.chain = (f) => (data) => from.Promise((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
-  Task2.ap = (arg) => (data) => from.Promise((signal) => Promise.all([toPromise(data, signal), toPromise(arg, signal)]).then(([f, a]) => f(a)));
-  Task2.tap = (f) => (data) => from.Promise(
+  Task2.tryCatch = (f, options) => fromPromise((signal) => globalThis.Promise.resolve().then(() => f(signal)).catch((err2) => options.onError(err2)));
+  Task2.map = (f) => (data) => fromPromise((signal) => toPromise(data, signal).then(f));
+  Task2.chain = (f) => (data) => fromPromise((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
+  Task2.ap = (arg) => (data) => fromPromise((signal) => Promise.all([toPromise(data, signal), toPromise(arg, signal)]).then(([f, a]) => f(a)));
+  Task2.tap = (f) => (data) => fromPromise(
     (signal) => toPromise(data, signal).then((a) => {
       f(a);
       return a;
     })
   );
-  Task2.all = (tasks) => from.Promise(
+  Task2.all = (tasks) => fromPromise(
     (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
-  Task2.delay = (duration) => (data) => from.Promise(
+  Task2.delay = (duration) => (data) => fromPromise(
     (signal) => new Promise((res) => {
       let timerId;
       const onAbort = () => {
@@ -2162,7 +2153,7 @@ var Task;
       }, getMs2(duration));
     })
   );
-  Task2.repeat = (options) => (task) => from.Promise((signal) => {
+  Task2.repeat = (options) => (task) => fromPromise((signal) => {
     const { times, delay: delayDuration } = options;
     if (times <= 0) {
       return Promise.resolve([]);
@@ -2196,7 +2187,7 @@ var Task;
     };
     return run2(times);
   });
-  Task2.repeatUntil = (options) => (task) => from.Promise((signal) => {
+  Task2.repeatUntil = (options) => (task) => fromPromise((signal) => {
     const { when: predicate, delay: delayDuration, maxAttempts } = options;
     const wait = () => new Promise((r) => {
       let timerId;
@@ -2236,7 +2227,7 @@ var Task;
       return () => Deferred.from.Promise(new Promise(() => {
       }));
     }
-    return from.Promise((outerSignal) => {
+    return fromPromise((outerSignal) => {
       const controllers = tasks.map(() => new AbortController());
       const onOuterAbort = () => {
         for (const ctrl of controllers) {
@@ -2265,8 +2256,8 @@ var Task;
       return Promise.race(promises);
     });
   };
-  Task2.sequence = (tasks) => from.Promise((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
-  Task2.sequential = (tasks) => from.Promise(async (signal) => {
+  Task2.sequence = (tasks) => fromPromise((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
+  Task2.sequential = (tasks) => fromPromise(async (signal) => {
     const results = [];
     for (const task of tasks) {
       if (signal?.aborted) {
@@ -2276,7 +2267,7 @@ var Task;
     }
     return results;
   });
-  Task2.timeout = (options) => (task) => from.Promise((outerSignal) => {
+  Task2.timeout = (options) => (task) => fromPromise((outerSignal) => {
     const { duration, onTimeout } = options;
     const controller = new AbortController();
     let timerId;

package/dist/{chunk-L6GLADRU.mjs → chunk-NIE7VVZU.js}

@@ -2,9 +2,8 @@ import {
   Deferred,
   Maybe,
   Result,
-  Task,
   isNonEmptyArr
-} from "./chunk-XFE3SQEE.mjs";
+} from "./chunk-MFJXL6J2.js";
 
 // src/Data/Arr.ts
 var ArrMaybe;
@@ -41,7 +40,7 @@ var ArrResult;
 })(ArrResult || (ArrResult = {}));
 var ArrTaskResult;
 ((ArrTaskResult2) => {
-  ArrTaskResult2.traverse = (f) => (data) => Task.from.Promise(async () => {
+  ArrTaskResult2.traverse = (f) => (data) => () => Deferred.from.Promise((async () => {
     const result = [];
     for (const a of data) {
       const r = await Deferred.to.Promise(f(a)());
@@ -51,12 +50,12 @@ var ArrTaskResult;
       result.push(r.value);
     }
     return Result.make.ok(result);
-  });
+  })());
   ArrTaskResult2.sequence = (data) => (0, ArrTaskResult2.traverse)((a) => a)(data);
 })(ArrTaskResult || (ArrTaskResult = {}));
 var ArrTask;
 ((ArrTask2) => {
-  ArrTask2.traverse = (f) => (data) => Task.from.Promise(() => Promise.all(data.map((a) => Deferred.to.Promise(f(a)()))));
+  ArrTask2.traverse = (f) => (data) => () => Deferred.from.Promise(Promise.all(data.map((a) => Deferred.to.Promise(f(a)()))));
   ArrTask2.sequence = (data) => (0, ArrTask2.traverse)((a) => a)(data);
   ArrTask2.Result = ArrTaskResult;
 })(ArrTask || (ArrTask = {}));