@nlozgachev/pipelined 0.58.0 → 0.60.0

package/dist/{chunk-FVWJMPQI.js → data.mjs}

@@ -1,9 +1,264 @@
-import {
-  Deferred,
-  Maybe,
-  Result,
-  isNonEmptyArr
-} from "./chunk-VYHAA4KO.js";
+// src/Core/Deferred.ts
+var Deferred;
+((Deferred2) => {
+  let from;
+  ((from2) => {
+    from2.Promise = (p) => (
+      // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
+      { then: ((f) => p.then(f)) }
+    );
+  })(from = Deferred2.from || (Deferred2.from = {}));
+  let to;
+  ((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/Maybe.ts
+var _none = { kind: "None" };
+var Maybe;
+((Maybe2) => {
+  let make;
+  ((make2) => {
+    make2.some = (value) => ({ kind: "Some", value });
+    make2.none = () => _none;
+  })(make = Maybe2.make || (Maybe2.make = {}));
+  let is;
+  ((is2) => {
+    is2.some = (data) => data.kind === "Some";
+    is2.none = (data) => data.kind === "None";
+  })(is = Maybe2.is || (Maybe2.is = {}));
+  let to;
+  ((to2) => {
+    to2.nullable = (data) => is.some(data) ? data.value : null;
+    to2.undefined = (data) => is.some(data) ? data.value : globalThis.undefined;
+    to2.Result = (onNone) => (data) => is.some(data) ? Result.make.ok(data.value) : Result.make.err(onNone());
+  })(to = Maybe2.to || (Maybe2.to = {}));
+  let from;
+  ((from2) => {
+    from2.nullable = (value) => value === null || value === void 0 ? make.none() : make.some(value);
+    from2.Predicate = (pred) => (a) => pred(a) ? make.some(a) : make.none();
+    from2.Result = (data) => Result.is.ok(data) ? make.some(data.value) : make.none();
+  })(from = Maybe2.from || (Maybe2.from = {}));
+  Maybe2.map = (f) => (data) => is.some(data) ? make.some(f(data.value)) : data;
+  Maybe2.chain = (f) => (data) => is.some(data) ? f(data.value) : data;
+  Maybe2.fold = (onNone, onSome) => (data) => is.some(data) ? onSome(data.value) : onNone();
+  Maybe2.match = (cases) => (data) => is.some(data) ? cases.some(data.value) : cases.none();
+  Maybe2.getOrElse = (defaultValue) => (data) => is.some(data) ? data.value : defaultValue();
+  Maybe2.tap = (f) => (data) => {
+    if (is.some(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Maybe2.filter = (predicate) => (data) => is.some(data) ? predicate(data.value) ? data : make.none() : data;
+  Maybe2.recover = (fallback) => (data) => is.some(data) ? data : fallback();
+  Maybe2.ap = (arg) => (data) => is.some(data) && is.some(arg) ? make.some(data.value(arg.value)) : make.none();
+  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
+  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
+    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Maybe2.struct = (fields) => {
+    const result = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const res = fields[key];
+        if (is.none(res)) {
+          return res;
+        }
+        result[key] = res.value;
+      }
+    }
+    return make.some(result);
+  };
+  Maybe2.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/Core/Result.ts
+var Result;
+((Result2) => {
+  let make;
+  ((make2) => {
+    make2.ok = (value) => ({ kind: "Ok", value });
+    make2.err = (e) => ({ kind: "Err", error: e });
+  })(make = Result2.make || (Result2.make = {}));
+  let is;
+  ((is2) => {
+    is2.ok = (data) => data.kind === "Ok";
+    is2.err = (data) => data.kind === "Err";
+  })(is = Result2.is || (Result2.is = {}));
+  Result2.tryCatch = (f, options) => {
+    try {
+      return make.ok(f());
+    } catch (error) {
+      return make.err(options.onError(error));
+    }
+  };
+  Result2.map = (f) => (data) => is.ok(data) ? make.ok(f(data.value)) : data;
+  Result2.mapError = (f) => (data) => is.err(data) ? make.err(f(data.error)) : data;
+  Result2.chain = (f) => (data) => is.ok(data) ? f(data.value) : data;
+  Result2.fold = (onErr, onOk) => (data) => is.ok(data) ? onOk(data.value) : onErr(data.error);
+  Result2.match = (cases) => (data) => is.ok(data) ? cases.ok(data.value) : cases.err(data.error);
+  Result2.getOrElse = (defaultValue) => (data) => is.ok(data) ? data.value : defaultValue();
+  Result2.tap = (f) => (data) => {
+    if (is.ok(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Result2.tapError = (f) => (data) => {
+    if (is.err(data)) {
+      f(data.error);
+    }
+    return data;
+  };
+  let from;
+  ((from2) => {
+    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.Validation = (combineErrors) => (val) => Validation.is.passed(val) ? make.ok(val.value) : make.err(combineErrors(val.errors));
+  })(from = Result2.from || (Result2.from = {}));
+  Result2.recover = (fallback) => (data) => is.ok(data) ? data : fallback(data.error);
+  Result2.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 = Result2.to || (Result2.to = {}));
+  Result2.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();
+  Result2.ap = (arg) => (data) => is.ok(data) && is.ok(arg) ? make.ok(data.value(arg.value)) : is.err(data) ? data : arg;
+  Result2.bindTo = (key) => (data) => (0, Result2.map)((a) => ({ [key]: a }))(data);
+  Result2.bind = (key, f) => (data) => (0, Result2.chain)(
+    (a) => (0, Result2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Result2.struct = (fields) => {
+    const result = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const res = fields[key];
+        if (is.err(res)) {
+          return res;
+        }
+        result[key] = res.value;
+      }
+    }
+    return make.ok(result);
+  };
+  Result2.ensure = (predicate, onFail) => (data) => is.err(data) ? data : predicate(data.value) ? data : make.err(onFail(data.value));
+  Result2.bimap = (onErr, onOk) => (data) => is.ok(data) ? make.ok(onOk(data.value)) : make.err(onErr(data.error));
+})(Result || (Result = {}));
+
+// src/internal/InternalTypes.ts
+var isNonEmptyArr = (list) => list.length > 0;
+
+// src/Core/Validation.ts
+var Validation;
+((Validation2) => {
+  let make;
+  ((make2) => {
+    make2.passed = (value) => ({ kind: "Passed", value });
+    make2.failed = (error) => ({ kind: "Failed", errors: [error] });
+    make2.failedAll = (errors) => ({ kind: "Failed", errors });
+  })(make = Validation2.make || (Validation2.make = {}));
+  let is;
+  ((is2) => {
+    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));
+    from2.nullable = (onNull) => (value) => value === null || value === void 0 ? make.failed(onNull()) : make.passed(value);
+    from2.Maybe = (onNone) => (maybe) => Maybe.is.none(maybe) ? make.failed(onNone()) : make.passed(maybe.value);
+    from2.Result = (data) => data.kind === "Ok" ? make.passed(data.value) : make.failed(data.error);
+  })(from = Validation2.from || (Validation2.from = {}));
+  Validation2.map = (f) => (data) => is.passed(data) ? make.passed(f(data.value)) : data;
+  Validation2.mapError = (f) => (data) => is.failed(data) ? make.failedAll(data.errors.map(f)) : data;
+  Validation2.ap = (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([...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();
+  Validation2.tap = (f) => (data) => {
+    if (is.passed(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Validation2.tapError = (f) => (data) => {
+    if (is.failed(data)) {
+      f(data.errors);
+    }
+    return data;
+  };
+  Validation2.recover = (fallback) => (data) => is.passed(data) ? data : fallback(data.errors);
+  Validation2.recoverUnless = (isBlocked, fallback) => (data) => is.failed(data) && !data.errors.some(isBlocked) ? fallback() : data;
+  let to;
+  ((to2) => {
+    function Result2(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 = Result2;
+    to2.Maybe = (data) => is.passed(data) ? Maybe.make.some(data.value) : Maybe.make.none();
+  })(to = Validation2.to || (Validation2.to = {}));
+  Validation2.product = (first, second) => {
+    if (is.passed(first)) {
+      return is.passed(second) ? make.passed([first.value, second.value]) : make.failedAll(second.errors);
+    }
+    return is.passed(second) ? make.failedAll(first.errors) : make.failedAll([...first.errors, ...second.errors]);
+  };
+  Validation2.productAll = (data) => {
+    const values = [];
+    const errors = [];
+    for (const v of data) {
+      if (is.passed(v)) {
+        values.push(v.value);
+      } else {
+        errors.push(...v.errors);
+      }
+    }
+    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(values);
+  };
+  Validation2.struct = (fields) => {
+    const record = {};
+    const errors = [];
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const val = fields[key];
+        if (is.passed(val)) {
+          record[key] = val.value;
+        } else {
+          errors.push(...val.errors);
+        }
+      }
+    }
+    return isNonEmptyArr(errors) ? make.failedAll(errors) : make.passed(record);
+  };
+})(Validation || (Validation = {}));
 
 // src/Data/Arr.ts
 var ArrMaybe;
@@ -187,7 +442,7 @@ var Arr;
     }
     return result;
   };
-  Arr2.uniq = (data) => [...new Set(data)];
+  Arr2.uniq = (data) => data.length <= 1 ? data : [...new Set(data)];
   Arr2.uniqBy = (f) => (data) => {
     const seen = /* @__PURE__ */ new Set();
     const result = [];
@@ -842,10 +1097,20 @@ var Num;
 
 // src/Data/Rec.ts
 var _isNonEmpty = (data) => Object.keys(data).length > 0;
+var _setKey = (record, key, value) => {
+  if (key === "__proto__") {
+    Object.defineProperty(record, key, { value, writable: true, enumerable: true, configurable: true });
+  } else {
+    record[key] = value;
+  }
+};
 var RecMaybe;
 ((RecMaybe2) => {
   RecMaybe2.traverse = (f) => (data) => {
     const recordKeys = Object.keys(data);
+    if (recordKeys.length === 0) {
+      return { kind: "Some", value: {} };
+    }
     const result = {};
     for (let i = 0; i < recordKeys.length; i++) {
       const key = recordKeys[i];
@@ -853,7 +1118,7 @@ var RecMaybe;
       if (maybeVal.kind === "None") {
         return maybeVal;
       }
-      Object.defineProperty(result, key, { value: maybeVal.value, writable: true, enumerable: true, configurable: true });
+      _setKey(result, key, maybeVal.value);
     }
     return { kind: "Some", value: result };
   };
@@ -870,7 +1135,7 @@ var RecResult;
       if (res.kind === "Err") {
         return res;
       }
-      Object.defineProperty(result, key, { value: res.value, writable: true, enumerable: true, configurable: true });
+      _setKey(result, key, res.value);
     }
     return { kind: "Ok", value: result };
   };
@@ -923,12 +1188,7 @@ var Rec;
     for (let i = 0; i < recordKeys.length; i++) {
       const maybeVal = f(recordValues[i]);
       if (maybeVal.kind === "Some") {
-        Object.defineProperty(result, recordKeys[i], {
-          value: maybeVal.value,
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
+        _setKey(result, recordKeys[i], maybeVal.value);
       }
     }
     return result;
@@ -939,16 +1199,7 @@ var Rec;
     const result = Object.create(Object.getPrototypeOf(data));
     for (let i = 0; i < recordKeys.length; i++) {
       const key = recordKeys[i];
-      if (key === "__proto__") {
-        Object.defineProperty(result, "__proto__", {
-          value: f(key, recordValues[i]),
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
-      } else {
-        result[key] = f(key, recordValues[i]);
-      }
+      _setKey(result, key, f(key, recordValues[i]));
     }
     return result;
   };
@@ -958,12 +1209,7 @@ var Rec;
     const result = Object.create(Object.getPrototypeOf(data));
     for (let i = 0; i < recordKeys.length; i++) {
       if (predicate(recordValues[i])) {
-        Object.defineProperty(result, recordKeys[i], {
-          value: recordValues[i],
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
+        _setKey(result, recordKeys[i], recordValues[i]);
       }
     }
     return result;
@@ -972,7 +1218,7 @@ var Rec;
     const result = {};
     for (const [k, v] of Object.entries(data)) {
       if (predicate(k, v)) {
-        Object.defineProperty(result, k, { value: v, writable: true, enumerable: true, configurable: true });
+        _setKey(result, k, v);
       }
     }
     return result;
@@ -992,7 +1238,7 @@ var Rec;
       if (Object.hasOwn(result, key)) {
         result[key].push(item);
       } else {
-        Object.defineProperty(result, key, { value: [item], writable: true, enumerable: true, configurable: true });
+        _setKey(result, key, [item]);
       }
     }
     return result;
@@ -1001,7 +1247,7 @@ var Rec;
     const result = {};
     for (const key of pickedKeys) {
       if (Object.hasOwn(data, key)) {
-        Object.defineProperty(result, key, { value: data[key], writable: true, enumerable: true, configurable: true });
+        _setKey(result, key, data[key]);
       }
     }
     return result;
@@ -1011,12 +1257,7 @@ var Rec;
     const result = {};
     for (const key of Object.keys(data)) {
       if (!omitSet.has(key)) {
-        Object.defineProperty(result, key, {
-          value: data[key],
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
+        _setKey(result, key, data[key]);
       }
     }
     return result;
@@ -1057,26 +1298,42 @@ var Rec;
   Rec2.mergeWith = mergeWith;
   Rec2.size = (data) => Object.keys(data).length;
   Rec2.mapKeys = (f) => (data) => {
+    const keys2 = Object.keys(data);
+    if (keys2.length === 0) {
+      return data;
+    }
     const result = {};
-    for (const [k, v] of Object.entries(data)) {
-      Object.defineProperty(result, f(k), { value: v, writable: true, enumerable: true, configurable: true });
+    for (let i = 0; i < keys2.length; i++) {
+      const k = keys2[i];
+      _setKey(result, f(k), data[k]);
     }
     return result;
   };
   Rec2.compact = (data) => {
+    const keys2 = Object.keys(data);
+    if (keys2.length === 0) {
+      return {};
+    }
     const result = {};
-    for (const [k, v] of Object.entries(data)) {
+    for (let i = 0; i < keys2.length; i++) {
+      const k = keys2[i];
+      const v = data[k];
       if (v.kind === "Some") {
-        Object.defineProperty(result, k, { value: v.value, writable: true, enumerable: true, configurable: true });
+        _setKey(result, k, v.value);
       }
     }
     return result;
   };
   Rec2.mapEntries = (f) => (data) => {
+    const keys2 = Object.keys(data);
+    if (keys2.length === 0) {
+      return {};
+    }
     const result = {};
-    for (const [k, v] of Object.entries(data)) {
-      const [newKey, newVal] = f(k, v);
-      Object.defineProperty(result, newKey, { value: newVal, writable: true, enumerable: true, configurable: true });
+    for (let i = 0; i < keys2.length; i++) {
+      const k = keys2[i];
+      const [newKey, newVal] = f(k, data[k]);
+      _setKey(result, newKey, newVal);
     }
     return result;
   };
@@ -1148,8 +1405,11 @@ var Str;
      * ```
      */
     int: (s) => {
-      const n = parseInt(s, 10);
-      return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
+      if (s.length === 0) {
+        return Maybe.make.none();
+      }
+      const n = Number.parseInt(s, 10);
+      return Number.isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
     },
     /**
      * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
@@ -1162,8 +1422,11 @@ var Str;
      * ```
      */
     float: (s) => {
-      const n = parseFloat(s);
-      return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
+      if (s.length === 0) {
+        return Maybe.make.none();
+      }
+      const n = Number.parseFloat(s);
+      return Number.isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
     }
   };
   Str2.parseJson = (s) => {
@@ -1311,7 +1574,6 @@ var Uniq;
   })(to = Uniq2.to || (Uniq2.to = {}));
   Uniq2.NonEmpty = UniqNonEmpty;
 })(Uniq || (Uniq = {}));
-
 export {
   Arr,
   BigNum,