@nlozgachev/pipelined 0.47.0 → 0.49.0

package/dist/{chunk-VSU36S2K.mjs → chunk-IHLH2XYQ.mjs}

@@ -1,6 +1,6 @@
 import {
   Duration
-} from "./chunk-XTVF5R6R.mjs";
+} from "./chunk-DENXUTKL.mjs";
 
 // src/Core/Combinable.ts
 var Combinable;
@@ -16,6 +16,26 @@ var Combinable;
     combine: (b) => (a) => Maybe.is.none(a) ? b : Maybe.is.none(b) ? a : Maybe.make.some(inner.combine(b.value)(a.value))
   });
   Combinable2.fold = (c) => (data) => data.reduce((acc, x) => c.combine(x)(acc), c.empty);
+  Combinable2.struct = (fields) => {
+    const empty = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        empty[key] = fields[key].empty;
+      }
+    }
+    return {
+      empty,
+      combine: (b) => (a) => {
+        const result = {};
+        for (const key in fields) {
+          if (Object.hasOwn(fields, key)) {
+            result[key] = fields[key].combine(b[key])(a[key]);
+          }
+        }
+        return result;
+      }
+    };
+  };
 })(Combinable || (Combinable = {}));
 
 // src/Core/Deferred.ts
@@ -32,6 +52,8 @@ var Deferred;
   ((to2) => {
     to2.Promise = (d) => new globalThis.Promise((resolve) => d.then(resolve));
   })(to = Deferred2.to || (Deferred2.to = {}));
+  Deferred2.all = (deferreds) => from.Promise(globalThis.Promise.all(deferreds.map((d) => to.Promise(d))));
+  Deferred2.race = (deferreds) => from.Promise(globalThis.Promise.race(deferreds.map((d) => to.Promise(d))));
 })(Deferred || (Deferred = {}));
 
 // src/Core/Equality.ts
@@ -44,6 +66,27 @@ var Equality;
   Equality2.array = (eq) => (a, b) => a.length === b.length && a.every((x, i) => eq(x, b[i]));
   Equality2.by = (f) => (eq) => (a, b) => eq(f(a), f(b));
   Equality2.and = (eq2) => (eq1) => (a, b) => eq1(a, b) && eq2(a, b);
+  Equality2.struct = (fields) => (a, b) => {
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        if (!fields[key](a[key], b[key])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  };
+  Equality2.tuple = (...equalities) => (a, b) => {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < equalities.length; i++) {
+      if (!equalities[i](a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  };
 })(Equality || (Equality = {}));
 
 // src/Core/Lazy.ts
@@ -123,6 +166,10 @@ var Logged;
   Logged2.bind = (key, f) => (data) => (0, Logged2.chain)(
     (a) => (0, Logged2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
+  Logged2.focus = (lens) => (f) => (data) => ({
+    value: lens.set(f(lens.get(data.value)))(data.value),
+    log: data.log
+  });
 })(Logged || (Logged = {}));
 
 // src/Core/Maybe.ts
@@ -182,6 +229,7 @@ var Maybe;
     }
     return make.some(result);
   };
+  Maybe3.transposeResult = (data) => is.none(data) ? Result.make.ok(make.none()) : Result.is.ok(data.value) ? Result.make.ok(make.some(data.value.value)) : Result.make.err(data.value.error);
 })(Maybe || (Maybe = {}));
 
 // src/internal/Op.util.ts
@@ -1333,6 +1381,25 @@ var Ordering;
     return r !== 0 ? r : ord2(a, b);
   };
   Ordering2.by = (f) => (ord) => (a, b) => ord(f(a), f(b));
+  Ordering2.byFields = (orderings) => (a, b) => {
+    for (let i = 0; i < orderings.length; i++) {
+      const res = orderings[i](a, b);
+      if (res !== 0) {
+        return res;
+      }
+    }
+    return 0;
+  };
+  Ordering2.tuple = (...orderings) => (a, b) => {
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+      const res = orderings[i](a[i], b[i]);
+      if (res !== 0) {
+        return res;
+      }
+    }
+    return a.length - b.length;
+  };
 })(Ordering || (Ordering = {}));
 
 // src/Core/Predicate.ts
@@ -1348,6 +1415,15 @@ var Predicate;
   ((from2) => {
     from2.Refinement = (r) => r;
   })(from = Predicate2.from || (Predicate2.from = {}));
+  Predicate2.match = (branches, fallback) => (a) => {
+    for (let i = 0; i < branches.length; i++) {
+      const [p, h] = branches[i];
+      if (p(a)) {
+        return h(a);
+      }
+    }
+    return fallback(a);
+  };
 })(Predicate || (Predicate = {}));
 
 // src/Core/Reader.ts
@@ -1547,11 +1623,11 @@ var Result;
     is2.ok = (data) => data.kind === "Ok";
     is2.err = (data) => data.kind === "Err";
   })(is = Result4.is || (Result4.is = {}));
-  Result4.tryCatch = (f, onError) => {
+  Result4.tryCatch = (f, options) => {
     try {
       return make.ok(f());
     } catch (error) {
-      return make.err(onError(error));
+      return make.err(options.onError(error));
     }
   };
   Result4.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
@@ -1577,20 +1653,23 @@ 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, onError) => (...args) => {
+    from2.throwable = (f, options) => (...args) => {
       try {
         return make.ok(f(...args));
       } catch (error) {
-        return make.err(onError(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);
   Result4.recoverUnless = (isBlocked, fallback) => (data) => is.err(data) && !isBlocked(data.error) ? fallback() : data;
   let to;
   ((to2) => {
     to2.Maybe = (data) => is.ok(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+    to2.Validation = (data) => Validation.from.Result(data);
   })(to = Result4.to || (Result4.to = {}));
+  Result4.transposeMaybe = (data) => is.err(data) ? Maybe.make.some(data) : Maybe.is.some(data.value) ? Maybe.make.some(make.ok(data.value.value)) : Maybe.make.none();
   Result4.ap = (arg) => (data) => is.ok(data) && is.ok(arg) ? make.ok(data.value(arg.value)) : is.err(data) ? data : arg;
   Result4.bindTo = (key) => (data) => (0, Result4.map)((a) => ({ [key]: a }))(data);
   Result4.bind = (key, f) => (data) => (0, Result4.chain)(
@@ -1609,6 +1688,8 @@ var Result;
     }
     return make.ok(result);
   };
+  Result4.ensure = (predicate, onFail) => (data) => is.err(data) ? data : predicate(data.value) ? data : make.err(onFail(data.value));
+  Result4.bimap = (onErr, onOk) => (data) => is.ok(data) ? make.ok(onOk(data.value)) : make.err(onErr(data.error));
 })(Result || (Result = {}));
 
 // src/Core/State.ts
@@ -1644,13 +1725,129 @@ var State;
   State2.bind = (key, f) => (data) => (0, State2.chain)(
     (a) => (0, State2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
+  State2.focus = (lens) => (stateOp) => (s) => {
+    const subState = lens.get(s);
+    const [b, newSubState] = stateOp(subState);
+    return [b, lens.set(newSubState)(s)];
+  };
 })(State || (State = {}));
 
+// src/Core/Stream.ts
+var Stream;
+((Stream2) => {
+  Stream2.make = (options) => ({
+    options,
+    _listeners: /* @__PURE__ */ new Set()
+  });
+  Stream2.emit = (target, message) => {
+    const targets = Array.isArray(target) ? target : [target];
+    const msg = message;
+    for (const stream of targets) {
+      const listeners = Array.from(stream._listeners);
+      for (const listener of listeners) {
+        try {
+          listener(msg);
+        } catch (err2) {
+          if (stream.options?.onError) {
+            stream.options.onError(err2);
+          } else {
+            throw err2;
+          }
+        }
+      }
+    }
+  };
+  Stream2.forward = (options) => {
+    const targets = Array.isArray(options.to) ? options.to : [options.to];
+    const filterSet = options.only ? new Set(options.only) : null;
+    const handler = (msg) => {
+      if (filterSet !== null && !filterSet.has(msg.kind)) {
+        return;
+      }
+      for (const target of targets) {
+        (0, Stream2.emit)(target, msg);
+      }
+    };
+    options.from._listeners.add(handler);
+    return () => {
+      options.from._listeners.delete(handler);
+    };
+  };
+  Stream2.listen = (stream, events, options) => {
+    const eventList = Array.isArray(events) ? events : [events];
+    const isOrdered = options?.ordered ?? false;
+    const isStrict = options?.strict ?? false;
+    const isOnce = options?.once ?? false;
+    const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
+    const createMatcher = (onMatch) => {
+      let sequenceIndex = 0;
+      return (msg) => {
+        if (resetKinds !== null && resetKinds.has(msg.kind)) {
+          sequenceIndex = 0;
+          return;
+        }
+        if (!isOrdered) {
+          if (eventList.includes(msg.kind)) {
+            onMatch(msg);
+          }
+          return;
+        }
+        const expectedKind = eventList[sequenceIndex];
+        if (msg.kind === expectedKind) {
+          sequenceIndex++;
+          if (sequenceIndex === eventList.length) {
+            sequenceIndex = 0;
+            onMatch(msg);
+          }
+        } else if (isStrict) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        } else if (eventList.includes(msg.kind)) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        }
+      };
+    };
+    return {
+      reduce: (reducer, initialState) => {
+        let currentState = initialState;
+        const listenerFn = createMatcher((msg) => {
+          currentState = reducer(msg, currentState);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return { unsubscribe, getState: () => currentState };
+      },
+      tap: (effect) => {
+        const listenerFn = createMatcher((msg) => {
+          effect(msg);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return unsubscribe;
+      }
+    };
+  };
+})(Stream || (Stream = {}));
+
 // src/Core/TaskMaybe.ts
 var TaskMaybe;
 ((TaskMaybe2) => {
-  TaskMaybe2.some = (value) => Task.resolve(Maybe.make.some(value));
-  TaskMaybe2.none = () => Task.resolve(Maybe.make.none());
+  let make;
+  ((make2) => {
+    make2.some = (value) => Task.resolve(Maybe.make.some(value));
+    make2.none = () => Task.resolve(Maybe.make.none());
+  })(make = TaskMaybe2.make || (TaskMaybe2.make = {}));
+  ({ some: TaskMaybe2.some } = make);
+  ({ none: TaskMaybe2.none } = make);
   let from;
   ((from2) => {
     from2.Maybe = (option) => Task.resolve(option);
@@ -1706,19 +1903,28 @@ var TaskMaybe;
 // src/Core/TaskResult.ts
 var TaskResult;
 ((TaskResult2) => {
-  TaskResult2.ok = (value) => Task.resolve(Result.make.ok(value));
-  TaskResult2.err = (error) => Task.resolve(Result.make.err(error));
+  let make;
+  ((make2) => {
+    make2.ok = (value) => Task.resolve(Result.make.ok(value));
+    make2.err = (error) => Task.resolve(Result.make.err(error));
+  })(make = TaskResult2.make || (TaskResult2.make = {}));
+  ({ ok: TaskResult2.ok } = make);
+  ({ err: TaskResult2.err } = make);
   let from;
   ((from2) => {
     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, onError) => (...args) => Task.from.Promise(
-      () => f(...args).then(Result.make.ok).catch((error) => Result.make.err(onError(error)))
+    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 = {}));
-  TaskResult2.tryCatch = (f, onError) => Task.from.Promise(
-    (signal) => Promise.resolve(f(signal)).then(Result.make.ok).catch((error) => Result.make.err(onError(error)))
+  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.map = (f) => (data) => Task.map(Result.map(f))(data);
   TaskResult2.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
@@ -1758,6 +1964,60 @@ var TaskResult;
       return Result.make.ok(record);
     });
   });
+  TaskResult2.retry = (policy) => (task) => Task.from.Promise((signal) => {
+    const { attempts } = policy;
+    const wait = (duration) => new Promise((res) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        res();
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return res();
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        res();
+      }, Duration.to.milliseconds(duration));
+    });
+    const executeAttempt = (attempt) => Deferred.to.Promise(task(signal)).then((res) => {
+      if (Result.is.ok(res) || attempt >= attempts || signal?.aborted) {
+        return res;
+      }
+      const delay = policy.getDelay(attempt);
+      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) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return Deferred.to.Promise(task(signal)).then(resolve);
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve(Result.make.err(options.onTimeout()));
+      }, ms);
+      Deferred.to.Promise(task(signal)).then((res) => {
+        clearTimeout(timerId);
+        signal?.removeEventListener("abort", onAbort);
+        resolve(res);
+      });
+    });
+  });
+  TaskResult2.allSettled = (tasks) => Task.from.Promise((signal) => Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal)))));
 })(TaskResult || (TaskResult = {}));
 
 // src/internal/InternalTypes.ts
@@ -1766,9 +2026,15 @@ var isNonEmptyArr = (list) => list.length > 0;
 // src/Core/TaskValidation.ts
 var TaskValidation;
 ((TaskValidation2) => {
-  TaskValidation2.passed = (value) => Task.resolve(Validation.make.passed(value));
-  TaskValidation2.failed = (error) => Task.resolve(Validation.make.failed(error));
-  TaskValidation2.failedAll = (errors) => Task.resolve(Validation.make.failedAll(errors));
+  let make;
+  ((make2) => {
+    make2.passed = (value) => Task.resolve(Validation.make.passed(value));
+    make2.failed = (error) => Task.resolve(Validation.make.failed(error));
+    make2.failedAll = (errors) => Task.resolve(Validation.make.failedAll(errors));
+  })(make = TaskValidation2.make || (TaskValidation2.make = {}));
+  ({ passed: TaskValidation2.passed } = make);
+  ({ failed: TaskValidation2.failed } = make);
+  ({ failedAll: TaskValidation2.failedAll } = make);
   let from;
   ((from2) => {
     from2.Validation = (validation) => Task.resolve(validation);
@@ -1986,7 +2252,8 @@ var Task;
     }
     return results;
   });
-  Task2.timeout = (duration, onTimeout) => (task) => from.Promise((outerSignal) => {
+  Task2.timeout = (options) => (task) => from.Promise((outerSignal) => {
+    const { duration, onTimeout } = options;
     const controller = new AbortController();
     let timerId;
     let cleanUp = () => {
@@ -2043,6 +2310,30 @@ var Task;
   Task2.bind = (key, f) => (data) => (0, Task2.chain)(
     (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
+  Task2.memoize = (task) => {
+    let cached = null;
+    return (signal) => {
+      if (cached === null) {
+        cached = task(signal);
+      }
+      return cached;
+    };
+  };
+  Task2.withProgress = (onProgress) => (task) => (signal) => {
+    onProgress(0);
+    const d = task(signal);
+    return Deferred.from.Promise(
+      Deferred.to.Promise(d).then((res) => {
+        onProgress(1);
+        return res;
+      })
+    );
+  };
+  Task2.withLabel = (label) => (task) => {
+    const fn = ((signal) => task(signal));
+    Object.defineProperty(fn, "label", { value: label, writable: false, enumerable: true, configurable: true });
+    return fn;
+  };
   Task2.Maybe = TaskMaybe;
   Task2.Result = TaskResult;
   Task2.Validation = TaskValidation;
@@ -2183,6 +2474,13 @@ var Validation;
     is2.passed = (data) => data.kind === "Passed";
     is2.failed = (data) => data.kind === "Failed";
   })(is = Validation2.is || (Validation2.is = {}));
+  Validation2.tryCatch = (f, options) => {
+    try {
+      return make.passed(f());
+    } catch (error) {
+      return make.failed(options.onError(error));
+    }
+  };
   let from;
   ((from2) => {
     from2.Predicate = (pred, onFalse) => (a) => pred(a) ? make.passed(a) : make.failed(onFalse(a));
@@ -2198,6 +2496,12 @@ var Validation;
     }
     return is.passed(arg) ? make.failedAll(data.errors) : make.failedAll([...data.errors, ...arg.errors]);
   };
+  Validation2.apCustom = (concat) => (arg) => (data) => {
+    if (is.passed(data)) {
+      return is.passed(arg) ? make.passed(data.value(arg.value)) : make.failedAll(arg.errors);
+    }
+    return is.passed(arg) ? make.failedAll(data.errors) : make.failedAll(concat(data.errors, arg.errors));
+  };
   Validation2.fold = (onFailed, onPassed) => (data) => is.passed(data) ? onPassed(data.value) : onFailed(data.errors);
   Validation2.match = (cases) => (data) => is.passed(data) ? cases.passed(data.value) : cases.failed(data.errors);
   Validation2.getOrElse = (defaultValue) => (data) => is.passed(data) ? data.value : defaultValue();
@@ -2217,7 +2521,14 @@ var Validation;
   Validation2.recoverUnless = (isBlocked, fallback) => (data) => is.failed(data) && !data.errors.some(isBlocked) ? fallback() : data;
   let to;
   ((to2) => {
-    to2.Result = (data) => is.passed(data) ? Result.make.ok(data.value) : Result.make.err(data.errors);
+    function Result4(arg) {
+      if (typeof arg === "function") {
+        const combine = arg;
+        return (val) => is.passed(val) ? Result.make.ok(val.value) : Result.make.err(combine(val.errors));
+      }
+      return is.passed(arg) ? Result.make.ok(arg.value) : Result.make.err(arg.errors);
+    }
+    to2.Result = Result4;
     to2.Maybe = (data) => is.passed(data) ? Maybe.make.some(data.value) : Maybe.make.none();
   })(to = Validation2.to || (Validation2.to = {}));
   Validation2.product = (first, second) => {
@@ -2273,6 +2584,7 @@ export {
   Resource,
   Result,
   State,
+  Stream,
   TaskMaybe,
   TaskResult,
   isNonEmptyArr,