@nlozgachev/pipelined 0.16.0 → 0.18.0

package/dist/index.js

@@ -26,8 +26,8 @@ __export(src_exports, {
   Dict: () => Dict,
   Lens: () => Lens,
   Logged: () => Logged,
+  Maybe: () => Maybe,
   Num: () => Num,
-  Option: () => Option,
   Optional: () => Optional,
   Predicate: () => Predicate,
   Reader: () => Reader,
@@ -39,7 +39,7 @@ __export(src_exports, {
   State: () => State,
   Str: () => Str,
   Task: () => Task,
-  TaskOption: () => TaskOption,
+  TaskMaybe: () => TaskMaybe,
   TaskResult: () => TaskResult,
   TaskValidation: () => TaskValidation,
   These: () => These,
@@ -120,7 +120,6 @@ function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {
         return f0(f1(f2(f3(f4(f5(f6(f7(f8(f9.apply(this, arguments))))))))));
       };
   }
-  return f0;
 }
 
 // src/Composition/converge.ts
@@ -183,7 +182,6 @@ function flow(ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
         return jk(ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))))));
       };
   }
-  return ab;
 }
 
 // src/Composition/fn.ts
@@ -377,37 +375,37 @@ var Result;
   };
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
   Result2.recoverUnless = (blockedErr, fallback) => (data) => (0, Result2.isErr)(data) && data.error !== blockedErr ? fallback() : data;
-  Result2.toOption = (data) => (0, Result2.isOk)(data) ? Option.some(data.value) : Option.none();
+  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.isErr)(data) ? data : arg;
 })(Result || (Result = {}));
 
-// src/Core/Option.ts
+// src/Core/Maybe.ts
 var _none = { kind: "None" };
-var Option;
-((Option2) => {
-  Option2.some = (value) => ({ kind: "Some", value });
-  Option2.isSome = (data) => data.kind === "Some";
-  Option2.none = () => _none;
-  Option2.isNone = (data) => data.kind === "None";
-  Option2.fromNullable = (value) => value === null || value === void 0 ? (0, Option2.none)() : (0, Option2.some)(value);
-  Option2.toNullable = (data) => (0, Option2.isSome)(data) ? data.value : null;
-  Option2.toUndefined = (data) => (0, Option2.isSome)(data) ? data.value : void 0;
-  Option2.fromUndefined = (value) => value === void 0 ? (0, Option2.none)() : (0, Option2.some)(value);
-  Option2.toResult = (onNone) => (data) => (0, Option2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
-  Option2.fromResult = (data) => Result.isOk(data) ? (0, Option2.some)(data.value) : (0, Option2.none)();
-  Option2.map = (f) => (data) => (0, Option2.isSome)(data) ? (0, Option2.some)(f(data.value)) : data;
-  Option2.chain = (f) => (data) => (0, Option2.isSome)(data) ? f(data.value) : data;
-  Option2.fold = (onNone, onSome) => (data) => (0, Option2.isSome)(data) ? onSome(data.value) : onNone();
-  Option2.match = (cases) => (data) => (0, Option2.isSome)(data) ? cases.some(data.value) : cases.none();
-  Option2.getOrElse = (defaultValue) => (data) => (0, Option2.isSome)(data) ? data.value : defaultValue();
-  Option2.tap = (f) => (data) => {
-    if ((0, Option2.isSome)(data)) f(data.value);
+var Maybe;
+((Maybe2) => {
+  Maybe2.some = (value) => ({ kind: "Some", value });
+  Maybe2.isSome = (data) => data.kind === "Some";
+  Maybe2.none = () => _none;
+  Maybe2.isNone = (data) => data.kind === "None";
+  Maybe2.fromNullable = (value) => value === null || value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
+  Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
+  Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
+  Maybe2.fromUndefined = (value) => value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
+  Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
+  Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
+  Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
+  Maybe2.chain = (f) => (data) => (0, Maybe2.isSome)(data) ? f(data.value) : data;
+  Maybe2.fold = (onNone, onSome) => (data) => (0, Maybe2.isSome)(data) ? onSome(data.value) : onNone();
+  Maybe2.match = (cases) => (data) => (0, Maybe2.isSome)(data) ? cases.some(data.value) : cases.none();
+  Maybe2.getOrElse = (defaultValue) => (data) => (0, Maybe2.isSome)(data) ? data.value : defaultValue();
+  Maybe2.tap = (f) => (data) => {
+    if ((0, Maybe2.isSome)(data)) f(data.value);
     return data;
   };
-  Option2.filter = (predicate) => (data) => (0, Option2.isSome)(data) ? predicate(data.value) ? data : (0, Option2.none)() : data;
-  Option2.recover = (fallback) => (data) => (0, Option2.isSome)(data) ? data : fallback();
-  Option2.ap = (arg) => (data) => (0, Option2.isSome)(data) && (0, Option2.isSome)(arg) ? (0, Option2.some)(data.value(arg.value)) : (0, Option2.none)();
-})(Option || (Option = {}));
+  Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
+  Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
+  Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
+})(Maybe || (Maybe = {}));
 
 // src/Core/Optional.ts
 var Optional;
@@ -416,12 +414,12 @@ var Optional;
   Optional2.prop = () => (key) => (0, Optional2.make)(
     (s) => {
       const val = s[key];
-      return val !== null && val !== void 0 ? Option.some(val) : Option.none();
+      return val !== null && val !== void 0 ? Maybe.some(val) : Maybe.none();
     },
     (a) => (s) => ({ ...s, [key]: a })
   );
   Optional2.index = (i) => (0, Optional2.make)(
-    (arr) => i >= 0 && i < arr.length ? Option.some(arr[i]) : Option.none(),
+    (arr) => i >= 0 && i < arr.length ? Maybe.some(arr[i]) : Maybe.none(),
     (a) => (arr) => {
       if (i < 0 || i >= arr.length) return arr;
       const copy = [...arr];
@@ -450,7 +448,7 @@ var Optional;
   Optional2.andThen = (inner) => (outer) => (0, Optional2.make)(
     (s) => {
       const mid = outer.get(s);
-      return mid.kind === "None" ? Option.none() : inner.get(mid.value);
+      return mid.kind === "None" ? Maybe.none() : inner.get(mid.value);
     },
     (b) => (s) => {
       const mid = outer.get(s);
@@ -460,7 +458,7 @@ var Optional;
   Optional2.andThenLens = (inner) => (outer) => (0, Optional2.make)(
     (s) => {
       const mid = outer.get(s);
-      return mid.kind === "None" ? Option.none() : Option.some(inner.get(mid.value));
+      return mid.kind === "None" ? Maybe.none() : Maybe.some(inner.get(mid.value));
     },
     (b) => (s) => {
       const mid = outer.get(s);
@@ -506,7 +504,7 @@ var Refinement;
   Refinement2.compose = (bc) => (ab) => (a) => ab(a) && bc(a);
   Refinement2.and = (second) => (first) => (a) => first(a) && second(a);
   Refinement2.or = (second) => (first) => (a) => first(a) || second(a);
-  Refinement2.toFilter = (r) => (a) => r(a) ? Option.some(a) : Option.none();
+  Refinement2.toFilter = (r) => (a) => r(a) ? Maybe.some(a) : Maybe.none();
   Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.err(onFail(a));
 })(Refinement || (Refinement = {}));
 
@@ -571,7 +569,7 @@ var RemoteData;
     return data;
   };
   RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
-  RemoteData2.toOption = (data) => (0, RemoteData2.isSuccess)(data) ? Option.some(data.value) : Option.none();
+  RemoteData2.toMaybe = (data) => (0, RemoteData2.isSuccess)(data) ? Maybe.some(data.value) : Maybe.none();
   RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
 })(RemoteData || (RemoteData = {}));
 
@@ -714,31 +712,31 @@ var State;
   State2.execute = (initialState) => (st) => st(initialState)[1];
 })(State || (State = {}));
 
-// src/Core/TaskOption.ts
-var TaskOption;
-((TaskOption2) => {
-  TaskOption2.some = (value) => Task.resolve(Option.some(value));
-  TaskOption2.none = () => Task.resolve(Option.none());
-  TaskOption2.fromOption = (option) => Task.resolve(option);
-  TaskOption2.fromTask = (task) => Task.map(Option.some)(task);
-  TaskOption2.tryCatch = (f) => Task.from(
-    () => f().then(Option.some).catch(() => Option.none())
+// src/Core/TaskMaybe.ts
+var TaskMaybe;
+((TaskMaybe2) => {
+  TaskMaybe2.some = (value) => Task.resolve(Maybe.some(value));
+  TaskMaybe2.none = () => Task.resolve(Maybe.none());
+  TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
+  TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
+  TaskMaybe2.tryCatch = (f) => Task.from(
+    () => f().then(Maybe.some).catch(() => Maybe.none())
   );
-  TaskOption2.map = (f) => (data) => Task.map(Option.map(f))(data);
-  TaskOption2.chain = (f) => (data) => Task.chain((option) => Option.isSome(option) ? f(option.value) : Task.resolve(Option.none()))(data);
-  TaskOption2.ap = (arg) => (data) => Task.from(
+  TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
+  TaskMaybe2.chain = (f) => (data) => Task.chain((option) => Maybe.isSome(option) ? f(option.value) : Task.resolve(Maybe.none()))(data);
+  TaskMaybe2.ap = (arg) => (data) => Task.from(
     () => Promise.all([
       Deferred.toPromise(data()),
       Deferred.toPromise(arg())
-    ]).then(([of_, oa]) => Option.ap(oa)(of_))
+    ]).then(([of_, oa]) => Maybe.ap(oa)(of_))
   );
-  TaskOption2.fold = (onNone, onSome) => (data) => Task.map(Option.fold(onNone, onSome))(data);
-  TaskOption2.match = (cases) => (data) => Task.map(Option.match(cases))(data);
-  TaskOption2.getOrElse = (defaultValue) => (data) => Task.map(Option.getOrElse(defaultValue))(data);
-  TaskOption2.tap = (f) => (data) => Task.map(Option.tap(f))(data);
-  TaskOption2.filter = (predicate) => (data) => Task.map(Option.filter(predicate))(data);
-  TaskOption2.toTaskResult = (onNone) => (data) => Task.map(Option.toResult(onNone))(data);
-})(TaskOption || (TaskOption = {}));
+  TaskMaybe2.fold = (onNone, onSome) => (data) => Task.map(Maybe.fold(onNone, onSome))(data);
+  TaskMaybe2.match = (cases) => (data) => Task.map(Maybe.match(cases))(data);
+  TaskMaybe2.getOrElse = (defaultValue) => (data) => Task.map(Maybe.getOrElse(defaultValue))(data);
+  TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
+  TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
+  TaskMaybe2.toTaskResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
+})(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
 var TaskResult;
@@ -774,6 +772,17 @@ var TaskResult;
     });
     return run(attempts);
   });
+  TaskResult2.pollUntil = (options) => (task) => Task.from(() => {
+    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) => {
+      if (Result.isErr(result)) return result;
+      if (predicate(result.value)) return result;
+      const ms = getDelay(attempt);
+      return (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve()).then(() => run(attempt + 1));
+    });
+    return run(1);
+  });
   TaskResult2.timeout = (ms, onTimeout) => (data) => Task.from(() => {
     let timerId;
     return Promise.race([
@@ -972,23 +981,23 @@ var isNonEmptyList = (list) => list.length > 0;
 // src/Utils/Arr.ts
 var Arr;
 ((Arr2) => {
-  Arr2.head = (data) => data.length > 0 ? Option.some(data[0]) : Option.none();
-  Arr2.last = (data) => data.length > 0 ? Option.some(data[data.length - 1]) : Option.none();
-  Arr2.tail = (data) => data.length > 0 ? Option.some(data.slice(1)) : Option.none();
-  Arr2.init = (data) => data.length > 0 ? Option.some(data.slice(0, -1)) : Option.none();
+  Arr2.head = (data) => data.length > 0 ? Maybe.some(data[0]) : Maybe.none();
+  Arr2.last = (data) => data.length > 0 ? Maybe.some(data[data.length - 1]) : Maybe.none();
+  Arr2.tail = (data) => data.length > 0 ? Maybe.some(data.slice(1)) : Maybe.none();
+  Arr2.init = (data) => data.length > 0 ? Maybe.some(data.slice(0, -1)) : Maybe.none();
   Arr2.findFirst = (predicate) => (data) => {
     const idx = data.findIndex(predicate);
-    return idx >= 0 ? Option.some(data[idx]) : Option.none();
+    return idx >= 0 ? Maybe.some(data[idx]) : Maybe.none();
   };
   Arr2.findLast = (predicate) => (data) => {
     for (let i = data.length - 1; i >= 0; i--) {
-      if (predicate(data[i])) return Option.some(data[i]);
+      if (predicate(data[i])) return Maybe.some(data[i]);
     }
-    return Option.none();
+    return Maybe.none();
   };
   Arr2.findIndex = (predicate) => (data) => {
     const idx = data.findIndex(predicate);
-    return idx >= 0 ? Option.some(idx) : Option.none();
+    return idx >= 0 ? Maybe.some(idx) : Maybe.none();
   };
   Arr2.map = (f) => (data) => {
     const n = data.length;
@@ -1036,7 +1045,11 @@ var Arr;
     }
     return result;
   };
-  Arr2.sortBy = (compare) => (data) => [...data].sort(compare);
+  Arr2.sortBy = (compare) => (data) => {
+    const arr = data;
+    if (typeof arr.toSorted === "function") return arr.toSorted(compare);
+    return [...data].sort(compare);
+  };
   Arr2.zip = (other) => (data) => {
     const len = Math.min(data.length, other.length);
     const result = new Array(len);
@@ -1086,10 +1099,10 @@ var Arr;
     const result = new Array(n);
     for (let i = 0; i < n; i++) {
       const mapped = f(data[i]);
-      if (mapped.kind === "None") return Option.none();
+      if (mapped.kind === "None") return Maybe.none();
       result[i] = mapped.value;
     }
-    return Option.some(result);
+    return Maybe.some(result);
   };
   Arr2.traverseResult = (f) => (data) => {
     const n = data.length;
@@ -1128,6 +1141,22 @@ var Arr;
     return true;
   };
   Arr2.reverse = (data) => [...data].reverse();
+  Arr2.insertAt = (index, item) => (data) => {
+    const i = Math.max(0, Math.min(index, data.length));
+    const arr = data;
+    if (typeof arr.toSpliced === "function") return arr.toSpliced(i, 0, item);
+    const result = [...data];
+    result.splice(i, 0, item);
+    return result;
+  };
+  Arr2.removeAt = (index) => (data) => {
+    if (index < 0 || index >= data.length) return data;
+    const arr = data;
+    if (typeof arr.toSpliced === "function") return arr.toSpliced(index, 1);
+    const result = [...data];
+    result.splice(index, 1);
+    return result;
+  };
   Arr2.take = (n) => (data) => n <= 0 ? [] : data.slice(0, n);
   Arr2.drop = (n) => (data) => data.slice(n);
   Arr2.takeWhile = (predicate) => (data) => {
@@ -1177,7 +1206,7 @@ var Dict;
     return result;
   };
   Dict2.has = (key) => (m) => m.has(key);
-  Dict2.lookup = (key) => (m) => m.has(key) ? Option.some(m.get(key)) : Option.none();
+  Dict2.lookup = (key) => (m) => m.has(key) ? Maybe.some(m.get(key)) : Maybe.none();
   Dict2.size = (m) => m.size;
   Dict2.isEmpty = (m) => m.size === 0;
   Dict2.keys = (m) => [...m.keys()];
@@ -1287,9 +1316,9 @@ var Num;
   Num2.clamp = (min, max) => (n) => Math.min(Math.max(n, min), max);
   Num2.between = (min, max) => (n) => n >= min && n <= max;
   Num2.parse = (s) => {
-    if (s.trim() === "") return Option.none();
+    if (s.trim() === "") return Maybe.none();
     const n = Number(s);
-    return isNaN(n) ? Option.none() : Option.some(n);
+    return isNaN(n) ? Maybe.none() : Maybe.some(n);
   };
   Num2.add = (b) => (a) => a + b;
   Num2.subtract = (b) => (a) => a - b;
@@ -1332,7 +1361,7 @@ var Rec;
     }
     return result;
   };
-  Rec2.lookup = (key) => (data) => Object.hasOwn(data, key) ? Option.some(data[key]) : Option.none();
+  Rec2.lookup = (key) => (data) => Object.hasOwn(data, key) ? { kind: "Some", value: data[key] } : { kind: "None" };
   Rec2.keys = (data) => Object.keys(data);
   Rec2.values = (data) => Object.values(data);
   Rec2.entries = (data) => Object.entries(data);
@@ -1412,7 +1441,7 @@ var Str;
      */
     int: (s) => {
       const n = parseInt(s, 10);
-      return isNaN(n) ? Option.none() : Option.some(n);
+      return isNaN(n) ? Maybe.none() : Maybe.some(n);
     },
     /**
      * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
@@ -1426,7 +1455,7 @@ var Str;
      */
     float: (s) => {
       const n = parseFloat(s);
-      return isNaN(n) ? Option.none() : Option.some(n);
+      return isNaN(n) ? Maybe.none() : Maybe.some(n);
     }
   };
 })(Str || (Str = {}));
@@ -1512,8 +1541,8 @@ var Uniq;
   Dict,
   Lens,
   Logged,
+  Maybe,
   Num,
-  Option,
   Optional,
   Predicate,
   Reader,
@@ -1525,7 +1554,7 @@ var Uniq;
   State,
   Str,
   Task,
-  TaskOption,
+  TaskMaybe,
   TaskResult,
   TaskValidation,
   These,

package/dist/index.mjs

@@ -26,7 +26,7 @@ import {
   uncurry,
   uncurry3,
   uncurry4
-} from "./chunk-KXAWFKQQ.mjs";
+} from "./chunk-5HMYR4XB.mjs";
 import {
   Lens,
   Logged,
@@ -37,13 +37,13 @@ import {
   RemoteData,
   Resource,
   State,
-  TaskOption,
+  TaskMaybe,
   TaskResult,
   TaskValidation,
   These,
   Tuple,
   Validation
-} from "./chunk-2XKWSZEU.mjs";
+} from "./chunk-UWGFO7BH.mjs";
 import {
   Arr,
   Dict,
@@ -51,13 +51,13 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-FAZN3IWZ.mjs";
+} from "./chunk-B3YNH6GZ.mjs";
 import {
   Deferred,
-  Option,
+  Maybe,
   Result,
   Task
-} from "./chunk-QPTGO5AS.mjs";
+} from "./chunk-EAR4TIGH.mjs";
 import {
   Brand
 } from "./chunk-BYWKZLHM.mjs";
@@ -71,8 +71,8 @@ export {
   Dict,
   Lens,
   Logged,
+  Maybe,
   Num,
-  Option,
   Optional,
   Predicate,
   Reader,
@@ -84,7 +84,7 @@ export {
   State,
   Str,
   Task,
-  TaskOption,
+  TaskMaybe,
   TaskResult,
   TaskValidation,
   These,