@valbuild/core 0.12.0

package/dist/result-b96df128.esm.js

@@ -0,0 +1,279 @@
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+function isNonEmpty(array) {
+  return array.length > 0;
+}
+function flatten(array) {
+  return array.flat(1);
+}
+function map$1(fn) {
+  function mapFn(array) {
+    return array.map(fn);
+  }
+  return mapFn;
+}
+
+var array = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  isNonEmpty: isNonEmpty,
+  flatten: flatten,
+  map: map$1
+});
+
+/**
+ * Singleton instance of Ok<void>. Used to optimize results whose Ok values are
+ * void.
+ */
+var voidOk = Object.freeze({
+  kind: "ok",
+  value: undefined
+});
+function ok(value) {
+  if (value === undefined) return voidOk;
+  return {
+    kind: "ok",
+    value: value
+  };
+}
+function err(error) {
+  return {
+    kind: "err",
+    error: error
+  };
+}
+function isOk(result) {
+  return result === voidOk || result.kind === "ok";
+}
+function isErr(result) {
+  return result !== voidOk && result.kind === "err";
+}
+/**
+ * If all results are Ok (or if results is empty), returns Ok with all the Ok
+ * values concatenated into an array. If any result is Err, returns Err with all
+ * Err values concatenated into an array.
+ *
+ * @see {@link all} for use with simple array types.
+ */
+function allT(results) {
+  var values = [];
+  var errors = [];
+  var _iterator = _createForOfIteratorHelper(results),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _result = _step.value;
+      if (isOk(_result)) {
+        values.push(_result.value);
+      } else {
+        errors.push(_result.error);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (isNonEmpty(errors)) {
+    return err(errors);
+  } else {
+    return ok(values);
+  }
+}
+
+/**
+ * If all results are Ok (or if results is empty), returns Ok with all the Ok
+ * values concatenated into an array. If any result is Err, returns Err with all
+ * Err values concatenated into an array.
+ *
+ * @see {@link allT} for use with tuple types.
+ */
+function all(results) {
+  return allT(results);
+}
+
+/**
+ * If all results are Ok (or if results is empty), returns Ok. If any result is
+ * Err, returns Err with all Err values concatenated into an array.
+ */
+function allV(results) {
+  var errs = [];
+  var _iterator2 = _createForOfIteratorHelper(results),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _result2 = _step2.value;
+      if (isErr(_result2)) {
+        errs.push(_result2.error);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (isNonEmpty(errs)) {
+    return err(errs);
+  }
+  return voidOk;
+}
+
+/**
+ * Perform a reduction over an array with a Result-returning reducer. If the
+ * reducer returns Ok, its value is used as the next value. If the reducer
+ * returns Err, it is returned immediately.
+ *
+ * flatMapReduce is a short-circuiting equivalent to:
+ * ```
+ * arr.reduce(
+ *   (accRes, current, currentIndex) =>
+ *     flatMap((acc) => reducer(acc, current, currentIndex))(accRes),
+ *   ok(initVal)
+ * )
+ * ```
+ */
+function flatMapReduce(reducer, initVal) {
+  return function (arr) {
+    var val = ok(initVal);
+    for (var i = 0; i < arr.length && isOk(val); ++i) {
+      val = reducer(val.value, arr[i], i);
+    }
+    return val;
+  };
+}
+function map(onOk) {
+  return function (result) {
+    if (isOk(result)) {
+      return ok(onOk(result.value));
+    } else {
+      return result;
+    }
+  };
+}
+function flatMap(onOk) {
+  return function (result) {
+    if (isOk(result)) {
+      return onOk(result.value);
+    } else {
+      return result;
+    }
+  };
+}
+function mapErr(onErr) {
+  return function (result) {
+    if (isErr(result)) {
+      return err(onErr(result.error));
+    } else {
+      return result;
+    }
+  };
+}
+function fromPredicate(refinement, onFalse) {
+  return function (value) {
+    if (refinement(value)) {
+      return ok(value);
+    } else {
+      return err(onFalse(value));
+    }
+  };
+}
+
+// NOTE: Function overload resolution seems to fail when declared as overloaded
+// function type, so a value with a callable type is used instead.
+var filterOrElse = function filterOrElse(refinement, onFalse) {
+  return function (result) {
+    if (isOk(result)) {
+      if (refinement(result.value)) {
+        return result;
+      } else {
+        return err(onFalse(result.value));
+      }
+    } else {
+      return result;
+    }
+  };
+};
+
+var result = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  voidOk: voidOk,
+  ok: ok,
+  err: err,
+  isOk: isOk,
+  isErr: isErr,
+  allT: allT,
+  all: all,
+  allV: allV,
+  flatMapReduce: flatMapReduce,
+  map: map,
+  flatMap: flatMap,
+  mapErr: mapErr,
+  fromPredicate: fromPredicate,
+  filterOrElse: filterOrElse
+});
+
+export { _createForOfIteratorHelper as _, isOk as a, _arrayLikeToArray as b, _unsupportedIterableToArray as c, array as d, err as e, isNonEmpty as f, flatMap as g, flatMapReduce as h, isErr as i, filterOrElse as j, mapErr as k, map$1 as l, map as m, all as n, ok as o, flatten as p, allT as q, result as r };

package/dist/util-030d8a1f.cjs.prod.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// "Ought to be enough for everybody" -- attributed to E. Åmdal
+
+function pipe(a) {
+  var current = a;
+  for (var _len = arguments.length, fns = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    fns[_key - 1] = arguments[_key];
+  }
+  for (var _i = 0, _fns = fns; _i < _fns.length; _i++) {
+    var fn = _fns[_i];
+    current = fn(current);
+  }
+  return current;
+}
+
+/**
+ * Runs the callback with the supplied value, then returns the value. Useful for
+ * debugging pipes.
+ */
+function tap(callback) {
+  return function (value) {
+    callback(value);
+    return value;
+  };
+}
+
+exports.pipe = pipe;
+exports.tap = tap;

package/dist/util-18613e99.esm.js

@@ -0,0 +1,26 @@
+// "Ought to be enough for everybody" -- attributed to E. Åmdal
+
+function pipe(a) {
+  var current = a;
+  for (var _len = arguments.length, fns = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    fns[_key - 1] = arguments[_key];
+  }
+  for (var _i = 0, _fns = fns; _i < _fns.length; _i++) {
+    var fn = _fns[_i];
+    current = fn(current);
+  }
+  return current;
+}
+
+/**
+ * Runs the callback with the supplied value, then returns the value. Useful for
+ * debugging pipes.
+ */
+function tap(callback) {
+  return function (value) {
+    callback(value);
+    return value;
+  };
+}
+
+export { pipe as p, tap as t };

package/dist/util-b213092b.cjs.dev.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// "Ought to be enough for everybody" -- attributed to E. Åmdal
+
+function pipe(a) {
+  var current = a;
+  for (var _len = arguments.length, fns = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    fns[_key - 1] = arguments[_key];
+  }
+  for (var _i = 0, _fns = fns; _i < _fns.length; _i++) {
+    var fn = _fns[_i];
+    current = fn(current);
+  }
+  return current;
+}
+
+/**
+ * Runs the callback with the supplied value, then returns the value. Useful for
+ * debugging pipes.
+ */
+function tap(callback) {
+  return function (value) {
+    callback(value);
+    return value;
+  };
+}
+
+exports.pipe = pipe;
+exports.tap = tap;

package/dist/valbuild-core.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index";
+//# sourceMappingURL=valbuild-core.cjs.d.ts.map

package/dist/valbuild-core.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valbuild-core.cjs.d.ts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}