@nlozgachev/pipelined 0.53.0 → 0.55.0

package/dist/composition.cjs

@@ -0,0 +1,533 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Composition/index.ts
+var Composition_exports = {};
+__export(Composition_exports, {
+  and: () => and,
+  compose: () => compose,
+  constFalse: () => constFalse,
+  constNull: () => constNull,
+  constTrue: () => constTrue,
+  constUndefined: () => constUndefined,
+  constVoid: () => constVoid,
+  constant: () => constant,
+  converge: () => converge,
+  curry: () => curry,
+  curry3: () => curry3,
+  curry4: () => curry4,
+  defaultTo: () => defaultTo,
+  flip: () => flip,
+  flow: () => flow,
+  identity: () => identity,
+  juxt: () => juxt,
+  memoize: () => memoize,
+  memoizeWeak: () => memoizeWeak,
+  not: () => not,
+  on: () => on,
+  once: () => once,
+  or: () => or,
+  pipe: () => pipe,
+  tap: () => tap,
+  tuple: () => tuple,
+  uncurry: () => uncurry,
+  uncurry3: () => uncurry3,
+  uncurry4: () => uncurry4,
+  untuple: () => untuple
+});
+module.exports = __toCommonJS(Composition_exports);
+
+// src/Composition/compose.ts
+function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {
+  const len = arguments.length;
+  switch (len) {
+    case 1: {
+      return f0;
+    }
+    case 2: {
+      return function() {
+        return f0(f1.apply(this, arguments));
+      };
+    }
+    case 3: {
+      return function() {
+        return f0(f1(f2.apply(this, arguments)));
+      };
+    }
+    case 4: {
+      return function() {
+        return f0(f1(f2(f3.apply(this, arguments))));
+      };
+    }
+    case 5: {
+      return function() {
+        return f0(f1(f2(f3(f4.apply(this, arguments)))));
+      };
+    }
+    case 6: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5.apply(this, arguments))))));
+      };
+    }
+    case 7: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5(f6.apply(this, arguments)))))));
+      };
+    }
+    case 8: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5(f6(f7.apply(this, arguments))))))));
+      };
+    }
+    case 9: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5(f6(f7(f8.apply(this, arguments)))))))));
+      };
+    }
+    case 10: {
+      return function() {
+        return f0(f1(f2(f3(f4(f5(f6(f7(f8(f9.apply(this, arguments))))))))));
+      };
+    }
+  }
+}
+
+// src/Composition/converge.ts
+function converge(f, transformers) {
+  return (a) => f(...transformers.map((t) => t(a)));
+}
+
+// src/Composition/curry.ts
+var curry = (f) => (a) => (b) => f(a, b);
+var curry3 = (f) => (a) => (b) => (c) => f(a, b, c);
+var curry4 = (f) => (a) => (b) => (c) => (d) => f(a, b, c, d);
+
+// src/Composition/flip.ts
+var flip = (f) => (b) => (a) => f(a)(b);
+
+// src/Composition/flow.ts
+function flow(ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
+  const len = arguments.length;
+  switch (len) {
+    case 0: {
+      return function(...args) {
+        return args[0];
+      };
+    }
+    case 1: {
+      return ab;
+    }
+    case 2: {
+      return function() {
+        return bc(ab.apply(this, arguments));
+      };
+    }
+    case 3: {
+      return function() {
+        return cd(bc(ab.apply(this, arguments)));
+      };
+    }
+    case 4: {
+      return function() {
+        return de(cd(bc(ab.apply(this, arguments))));
+      };
+    }
+    case 5: {
+      return function() {
+        return ef(de(cd(bc(ab.apply(this, arguments)))));
+      };
+    }
+    case 6: {
+      return function() {
+        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+      };
+    }
+    case 7: {
+      return function() {
+        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+      };
+    }
+    case 8: {
+      return function() {
+        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+      };
+    }
+    case 9: {
+      return function() {
+        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+      };
+    }
+    case 10: {
+      return function() {
+        return jk(ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))))));
+      };
+    }
+  }
+}
+var when = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
+var unless = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
+var either = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
+var struct = (fields) => (a) => {
+  const result = {};
+  for (const key of Object.keys(fields)) {
+    result[key] = fields[key](a);
+  }
+  return result;
+};
+function safe(...fns) {
+  return (a) => {
+    let result = a;
+    if (result === null || result === void 0) {
+      return result;
+    }
+    for (const fn of fns) {
+      result = fn(result);
+      if (result === null || result === void 0) {
+        return result;
+      }
+    }
+    return result;
+  };
+}
+function async(...fns) {
+  return async (a) => {
+    let result = await a;
+    for (const fn of fns) {
+      result = await fn(result);
+    }
+    return result;
+  };
+}
+flow.when = when;
+flow.unless = unless;
+flow.either = either;
+flow.struct = struct;
+flow.safe = safe;
+flow.async = async;
+flow.try = (f, onError) => (a) => {
+  try {
+    return f(a);
+  } catch (error) {
+    return onError(error, a);
+  }
+};
+
+// src/Composition/fn.ts
+var identity = (a) => a;
+var constant = (a) => () => a;
+var constTrue = () => true;
+var constFalse = () => false;
+var constNull = () => null;
+var constUndefined = () => void 0;
+var constVoid = () => {
+};
+var and = (p1, p2) => (...args) => p1(...args) && p2(...args);
+var or = (p1, p2) => (...args) => p1(...args) || p2(...args);
+var once = (f) => {
+  let called = false;
+  let result;
+  return () => {
+    if (!called) {
+      result = f();
+      called = true;
+    }
+    return result;
+  };
+};
+var defaultTo = (fallback) => (a) => a === null || a === void 0 ? fallback : a;
+var tuple = (f) => (args) => f(...args);
+var untuple = (f) => (...args) => f(args);
+
+// src/Composition/juxt.ts
+function juxt(fns) {
+  return (a) => fns.map((f) => f(a));
+}
+
+// src/Composition/memoize.ts
+var memoize = (f, options) => {
+  const cache = /* @__PURE__ */ new Map();
+  const keyFn = options?.key ?? ((a) => a);
+  return (a) => {
+    const key = keyFn(a);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = f(a);
+    cache.set(key, result);
+    return result;
+  };
+};
+var memoizeWeak = (f) => {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return (a) => {
+    if (cache.has(a)) {
+      return cache.get(a);
+    }
+    const result = f(a);
+    cache.set(a, result);
+    return result;
+  };
+};
+
+// src/Composition/not.ts
+var not = (predicate) => (...args) => !predicate(...args);
+
+// src/Composition/on.ts
+var on = (f, g) => (a, b) => f(g(a), g(b));
+
+// src/Composition/pipe.ts
+function pipe(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
+  switch (arguments.length) {
+    case 1: {
+      return a;
+    }
+    case 2: {
+      return ab(a);
+    }
+    case 3: {
+      return bc(ab(a));
+    }
+    case 4: {
+      return cd(bc(ab(a)));
+    }
+    case 5: {
+      return de(cd(bc(ab(a))));
+    }
+    case 6: {
+      return ef(de(cd(bc(ab(a)))));
+    }
+    case 7: {
+      return fg(ef(de(cd(bc(ab(a))))));
+    }
+    case 8: {
+      return gh(fg(ef(de(cd(bc(ab(a)))))));
+    }
+    case 9: {
+      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+    }
+    case 10: {
+      return ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))));
+    }
+    case 11: {
+      return jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))));
+    }
+  }
+}
+var when2 = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
+var unless2 = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
+var either2 = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
+var struct2 = (fields) => (a) => {
+  const result = {};
+  for (const key of Object.keys(fields)) {
+    result[key] = fields[key](a);
+  }
+  return result;
+};
+function safe2(a, ...fns) {
+  let result = a;
+  if (result === null || result === void 0) {
+    return result;
+  }
+  for (const fn of fns) {
+    result = fn(result);
+    if (result === null || result === void 0) {
+      return result;
+    }
+  }
+  return result;
+}
+async function async2(a, ...fns) {
+  let result = await a;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+pipe.when = when2;
+pipe.unless = unless2;
+pipe.either = either2;
+pipe.struct = struct2;
+pipe.safe = safe2;
+pipe.async = async2;
+pipe.try = (f, onError) => (a) => {
+  try {
+    return f(a);
+  } catch (error) {
+    return onError(error, a);
+  }
+};
+
+// src/Composition/tap.ts
+var import_node_util = require("util");
+
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  Brand2.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));
+
+// src/Types/Duration.ts
+var Duration;
+((Duration2) => {
+  const wrap = Brand.wrap();
+  Duration2.milliseconds = (ms) => wrap(ms);
+  Duration2.seconds = (s) => wrap(s * 1e3);
+  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
+  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
+  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
+  let to;
+  ((to2) => {
+    to2.milliseconds = (d) => Brand.unwrap(d);
+    to2.seconds = (d) => Brand.unwrap(d) / 1e3;
+    to2.minutes = (d) => Brand.unwrap(d) / (60 * 1e3);
+    to2.hours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
+    to2.days = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  })(to = Duration2.to || (Duration2.to = {}));
+  Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
+  Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
+})(Duration || (Duration = {}));
+
+// src/Composition/tap.ts
+function tap(f) {
+  return (a) => {
+    f(a);
+    return a;
+  };
+}
+((tap2) => {
+  tap2.log = (options) => (a) => {
+    const logger = options?.logger ?? console.log;
+    const formatter = options?.formatter ?? ((val) => {
+      try {
+        return typeof val === "object" && val !== null ? JSON.stringify(val) : String(val);
+      } catch {
+        return String(val);
+      }
+    });
+    const formatted = formatter(a);
+    if (options?.label !== void 0) {
+      logger(`[${options.label}]: ${formatted}`);
+    } else {
+      logger(formatted);
+    }
+    return a;
+  };
+  tap2.inspect = (options) => (a) => {
+    const label = options?.label;
+    const depth = options?.depth ?? null;
+    const colors = options?.colors ?? true;
+    let formatted;
+    if (typeof import_node_util.inspect === "function") {
+      formatted = (0, import_node_util.inspect)(a, { depth, colors });
+    } else {
+      try {
+        formatted = JSON.stringify(a, null, 2);
+      } catch {
+        formatted = String(a);
+      }
+    }
+    if (label !== void 0) {
+      console.log(`[${label}]: ${formatted}`);
+    } else {
+      console.log(formatted);
+    }
+    return a;
+  };
+  tap2.async = (fn, options) => (a) => {
+    const onError = options?.onError ?? console.error;
+    Promise.resolve(fn(a)).catch((err) => {
+      onError(err);
+    });
+    return a;
+  };
+  tap2.time = (fn, config) => (a) => {
+    const start = performance.now();
+    const triggerFinish = (duration) => {
+      if (config.label !== void 0) {
+        console.log(`[${config.label}]: ${Duration.to.milliseconds(duration)}ms`);
+      } else {
+        config.onFinish(duration);
+      }
+    };
+    try {
+      const res = fn(a);
+      if (res !== null && (typeof res === "object" || typeof res === "function") && typeof res.then === "function") {
+        res.then(() => {
+          const duration = Duration.milliseconds(performance.now() - start);
+          triggerFinish(duration);
+        }, () => {
+          const duration = Duration.milliseconds(performance.now() - start);
+          triggerFinish(duration);
+        });
+      } else {
+        const duration = Duration.milliseconds(performance.now() - start);
+        triggerFinish(duration);
+      }
+    } catch (err) {
+      const duration = Duration.milliseconds(performance.now() - start);
+      triggerFinish(duration);
+      throw err;
+    }
+    return a;
+  };
+})(tap || (tap = {}));
+
+// src/Composition/uncurry.ts
+function uncurry(f) {
+  return (...args) => {
+    const inner = f(...args.slice(0, f.length));
+    return inner.length === 0 ? inner() : inner(...args.slice(f.length));
+  };
+}
+var uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
+var uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  and,
+  compose,
+  constFalse,
+  constNull,
+  constTrue,
+  constUndefined,
+  constVoid,
+  constant,
+  converge,
+  curry,
+  curry3,
+  curry4,
+  defaultTo,
+  flip,
+  flow,
+  identity,
+  juxt,
+  memoize,
+  memoizeWeak,
+  not,
+  on,
+  once,
+  or,
+  pipe,
+  tap,
+  tuple,
+  uncurry,
+  uncurry3,
+  uncurry4,
+  untuple
+});

package/dist/{composition.d.mts → composition.d.cts}

@@ -1,5 +1,5 @@
-import { A as Awaitable, T as Thenable } from './InternalTypes-CDiDBAY4.mjs';
-import { D as Duration } from './Duration-B8joKzro.mjs';
+import { A as Awaitable, T as Thenable } from './InternalTypes-DuK_XpTi.cjs';
+import { D as Duration } from './Duration-B8joKzro.cjs';
 
 /**
  * Composes functions from right to left, returning a new function.