@nlozgachev/pipelined 0.11.0 → 0.13.0

package/dist/utils.mjs

@@ -0,0 +1,553 @@
+import {
+  Deferred,
+  Option,
+  Result,
+  Task
+} from "./chunk-QPTGO5AS.mjs";
+import {
+  isNonEmptyList
+} from "./chunk-DBIC62UV.mjs";
+
+// 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.findFirst = (predicate) => (data) => {
+    const idx = data.findIndex(predicate);
+    return idx >= 0 ? Option.some(data[idx]) : Option.none();
+  };
+  Arr2.findLast = (predicate) => (data) => {
+    for (let i = data.length - 1; i >= 0; i--) {
+      if (predicate(data[i])) return Option.some(data[i]);
+    }
+    return Option.none();
+  };
+  Arr2.findIndex = (predicate) => (data) => {
+    const idx = data.findIndex(predicate);
+    return idx >= 0 ? Option.some(idx) : Option.none();
+  };
+  Arr2.map = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) result[i] = f(data[i]);
+    return result;
+  };
+  Arr2.filter = (predicate) => (data) => {
+    const n = data.length;
+    const result = [];
+    for (let i = 0; i < n; i++) {
+      if (predicate(data[i])) result.push(data[i]);
+    }
+    return result;
+  };
+  Arr2.partition = (predicate) => (data) => {
+    const pass = [];
+    const fail = [];
+    for (const a of data) {
+      (predicate(a) ? pass : fail).push(a);
+    }
+    return [pass, fail];
+  };
+  Arr2.groupBy = (f) => (data) => {
+    const result = {};
+    for (const a of data) {
+      const key = f(a);
+      if (!result[key]) result[key] = [];
+      result[key].push(a);
+    }
+    return result;
+  };
+  Arr2.uniq = (data) => [
+    ...new Set(data)
+  ];
+  Arr2.uniqBy = (f) => (data) => {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const a of data) {
+      const key = f(a);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(a);
+      }
+    }
+    return result;
+  };
+  Arr2.sortBy = (compare) => (data) => [...data].sort(compare);
+  Arr2.zip = (other) => (data) => {
+    const len = Math.min(data.length, other.length);
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+      result[i] = [data[i], other[i]];
+    }
+    return result;
+  };
+  Arr2.zipWith = (f) => (other) => (data) => {
+    const len = Math.min(data.length, other.length);
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+      result[i] = f(data[i], other[i]);
+    }
+    return result;
+  };
+  Arr2.intersperse = (sep) => (data) => {
+    if (data.length <= 1) return data;
+    const result = [data[0]];
+    for (let i = 1; i < data.length; i++) {
+      result.push(sep, data[i]);
+    }
+    return result;
+  };
+  Arr2.chunksOf = (n) => (data) => {
+    if (n <= 0) return [];
+    const result = [];
+    for (let i = 0; i < data.length; i += n) {
+      result.push(data.slice(i, i + n));
+    }
+    return result;
+  };
+  Arr2.flatten = (data) => [].concat(...data);
+  Arr2.flatMap = (f) => (data) => {
+    const n = data.length;
+    const result = [];
+    for (let i = 0; i < n; i++) {
+      const chunk = f(data[i]);
+      const m = chunk.length;
+      for (let j = 0; j < m; j++) result.push(chunk[j]);
+    }
+    return result;
+  };
+  Arr2.reduce = (initial, f) => (data) => data.reduce(f, initial);
+  Arr2.traverse = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "None") return Option.none();
+      result[i] = mapped.value;
+    }
+    return Option.some(result);
+  };
+  Arr2.traverseResult = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Error") return mapped;
+      result[i] = mapped.value;
+    }
+    return Result.ok(result);
+  };
+  Arr2.traverseTask = (f) => (data) => Task.from(() => Promise.all(data.map((a) => Deferred.toPromise(f(a)()))));
+  Arr2.sequence = (data) => (0, Arr2.traverse)((a) => a)(data);
+  Arr2.sequenceResult = (data) => (0, Arr2.traverseResult)((a) => a)(data);
+  Arr2.sequenceTask = (data) => (0, Arr2.traverseTask)((a) => a)(data);
+  Arr2.traverseTaskResult = (f) => (data) => Task.from(async () => {
+    const result = [];
+    for (const a of data) {
+      const r = await Deferred.toPromise(f(a)());
+      if (Result.isErr(r)) return r;
+      result.push(r.value);
+    }
+    return Result.ok(result);
+  });
+  Arr2.sequenceTaskResult = (data) => (0, Arr2.traverseTaskResult)((a) => a)(data);
+  Arr2.isNonEmpty = (data) => isNonEmptyList(data);
+  Arr2.size = (data) => data.length;
+  Arr2.some = (predicate) => (data) => {
+    const n = data.length;
+    for (let i = 0; i < n; i++) if (predicate(data[i])) return true;
+    return false;
+  };
+  Arr2.every = (predicate) => (data) => {
+    const n = data.length;
+    for (let i = 0; i < n; i++) if (!predicate(data[i])) return false;
+    return true;
+  };
+  Arr2.reverse = (data) => [...data].reverse();
+  Arr2.take = (n) => (data) => n <= 0 ? [] : data.slice(0, n);
+  Arr2.drop = (n) => (data) => data.slice(n);
+  Arr2.takeWhile = (predicate) => (data) => {
+    const result = [];
+    for (const a of data) {
+      if (!predicate(a)) break;
+      result.push(a);
+    }
+    return result;
+  };
+  Arr2.dropWhile = (predicate) => (data) => {
+    let i = 0;
+    while (i < data.length && predicate(data[i])) i++;
+    return data.slice(i);
+  };
+  Arr2.scan = (initial, f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    let acc = initial;
+    for (let i = 0; i < n; i++) {
+      acc = f(acc, data[i]);
+      result[i] = acc;
+    }
+    return result;
+  };
+  Arr2.splitAt = (index) => (data) => {
+    const i = Math.max(0, index);
+    return [data.slice(0, i), data.slice(i)];
+  };
+})(Arr || (Arr = {}));
+
+// src/Utils/Dict.ts
+var Dict;
+((Dict2) => {
+  Dict2.empty = () => new globalThis.Map();
+  Dict2.singleton = (key, value) => new globalThis.Map([[key, value]]);
+  Dict2.fromEntries = (entries2) => new globalThis.Map(entries2);
+  Dict2.fromRecord = (rec) => new globalThis.Map(Object.entries(rec));
+  Dict2.groupBy = (keyFn) => (items) => {
+    const result = new globalThis.Map();
+    for (const item of items) {
+      const key = keyFn(item);
+      const arr = result.get(key);
+      if (arr !== void 0) arr.push(item);
+      else result.set(key, [item]);
+    }
+    return result;
+  };
+  Dict2.has = (key) => (m) => m.has(key);
+  Dict2.lookup = (key) => (m) => m.has(key) ? Option.some(m.get(key)) : Option.none();
+  Dict2.size = (m) => m.size;
+  Dict2.isEmpty = (m) => m.size === 0;
+  Dict2.keys = (m) => [...m.keys()];
+  Dict2.values = (m) => [...m.values()];
+  Dict2.entries = (m) => [...m.entries()];
+  Dict2.insert = (key, value) => (m) => {
+    const result = new globalThis.Map(m);
+    result.set(key, value);
+    return result;
+  };
+  Dict2.remove = (key) => (m) => {
+    if (!m.has(key)) return m;
+    const result = new globalThis.Map(m);
+    result.delete(key);
+    return result;
+  };
+  Dict2.upsert = (key, f) => (m) => {
+    const result = new globalThis.Map(m);
+    result.set(key, f((0, Dict2.lookup)(key)(m)));
+    return result;
+  };
+  Dict2.map = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      result.set(k, f(v));
+    }
+    return result;
+  };
+  Dict2.mapWithKey = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      result.set(k, f(k, v));
+    }
+    return result;
+  };
+  Dict2.filter = (predicate) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (predicate(v)) result.set(k, v);
+    }
+    return result;
+  };
+  Dict2.filterWithKey = (predicate) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (predicate(k, v)) result.set(k, v);
+    }
+    return result;
+  };
+  Dict2.compact = (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (v.kind === "Some") result.set(k, v.value);
+    }
+    return result;
+  };
+  Dict2.union = (other) => (m) => {
+    const result = new globalThis.Map(m);
+    for (const [k, v] of other) {
+      result.set(k, v);
+    }
+    return result;
+  };
+  Dict2.intersection = (other) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (other.has(k)) result.set(k, v);
+    }
+    return result;
+  };
+  Dict2.difference = (other) => (m) => {
+    const result = new globalThis.Map();
+    for (const [k, v] of m) {
+      if (!other.has(k)) result.set(k, v);
+    }
+    return result;
+  };
+  Dict2.reduce = (init, f) => (m) => {
+    let acc = init;
+    for (const v of m.values()) {
+      acc = f(acc, v);
+    }
+    return acc;
+  };
+  Dict2.reduceWithKey = (init, f) => (m) => {
+    let acc = init;
+    for (const [k, v] of m) {
+      acc = f(acc, v, k);
+    }
+    return acc;
+  };
+  Dict2.toRecord = (m) => Object.fromEntries(m);
+})(Dict || (Dict = {}));
+
+// src/Utils/Num.ts
+var Num;
+((Num2) => {
+  Num2.range = (from, to, step = 1) => {
+    if (step <= 0 || from > to) return [];
+    const count = Math.floor((to - from) / step) + 1;
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = from + i * step;
+    }
+    return result;
+  };
+  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();
+    const n = Number(s);
+    return isNaN(n) ? Option.none() : Option.some(n);
+  };
+  Num2.add = (b) => (a) => a + b;
+  Num2.subtract = (b) => (a) => a - b;
+  Num2.multiply = (b) => (a) => a * b;
+  Num2.divide = (b) => (a) => a / b;
+})(Num || (Num = {}));
+
+// src/Utils/Rec.ts
+var Rec;
+((Rec2) => {
+  Rec2.map = (f) => (data) => {
+    const keys2 = Object.keys(data);
+    const vals = Object.values(data);
+    const result = {};
+    for (let i = 0; i < keys2.length; i++) {
+      result[keys2[i]] = f(vals[i]);
+    }
+    return result;
+  };
+  Rec2.mapWithKey = (f) => (data) => {
+    const keys2 = Object.keys(data);
+    const vals = Object.values(data);
+    const result = {};
+    for (let i = 0; i < keys2.length; i++) {
+      result[keys2[i]] = f(keys2[i], vals[i]);
+    }
+    return result;
+  };
+  Rec2.filter = (predicate) => (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (predicate(v)) result[k] = v;
+    }
+    return result;
+  };
+  Rec2.filterWithKey = (predicate) => (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (predicate(k, v)) result[k] = v;
+    }
+    return result;
+  };
+  Rec2.lookup = (key) => (data) => Object.hasOwn(data, key) ? Option.some(data[key]) : Option.none();
+  Rec2.keys = (data) => Object.keys(data);
+  Rec2.values = (data) => Object.values(data);
+  Rec2.entries = (data) => Object.entries(data);
+  Rec2.fromEntries = (data) => Object.fromEntries(data);
+  Rec2.groupBy = (keyFn) => (items) => {
+    const result = {};
+    for (const item of items) {
+      const key = keyFn(item);
+      if (key in result) result[key].push(item);
+      else result[key] = [item];
+    }
+    return result;
+  };
+  Rec2.pick = (...pickedKeys) => (data) => {
+    const result = {};
+    for (const key of pickedKeys) {
+      if (Object.hasOwn(data, key)) {
+        result[key] = data[key];
+      }
+    }
+    return result;
+  };
+  Rec2.omit = (...omittedKeys) => (data) => {
+    const omitSet = new Set(omittedKeys);
+    const result = {};
+    for (const key of Object.keys(data)) {
+      if (!omitSet.has(key)) {
+        result[key] = data[key];
+      }
+    }
+    return result;
+  };
+  Rec2.merge = (other) => (data) => ({
+    ...data,
+    ...other
+  });
+  Rec2.isEmpty = (data) => Object.keys(data).length === 0;
+  Rec2.size = (data) => Object.keys(data).length;
+  Rec2.mapKeys = (f) => (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      result[f(k)] = v;
+    }
+    return result;
+  };
+  Rec2.compact = (data) => {
+    const result = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (v.kind === "Some") result[k] = v.value;
+    }
+    return result;
+  };
+})(Rec || (Rec = {}));
+
+// src/Utils/Str.ts
+var Str;
+((Str2) => {
+  Str2.split = (separator) => (s) => s.split(separator);
+  Str2.trim = (s) => s.trim();
+  Str2.includes = (substring) => (s) => s.includes(substring);
+  Str2.startsWith = (prefix) => (s) => s.startsWith(prefix);
+  Str2.endsWith = (suffix) => (s) => s.endsWith(suffix);
+  Str2.toUpperCase = (s) => s.toUpperCase();
+  Str2.toLowerCase = (s) => s.toLowerCase();
+  Str2.lines = (s) => s.split(/\r?\n|\r/);
+  Str2.words = (s) => s.trim().split(/\s+/).filter(Boolean);
+  Str2.parse = {
+    /**
+     * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
+     *
+     * @example
+     * ```ts
+     * Str.parse.int("42");   // Some(42)
+     * Str.parse.int("3.7");  // Some(3)
+     * Str.parse.int("abc");  // None
+     * ```
+     */
+    int: (s) => {
+      const n = parseInt(s, 10);
+      return isNaN(n) ? Option.none() : Option.some(n);
+    },
+    /**
+     * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
+     *
+     * @example
+     * ```ts
+     * Str.parse.float("3.14"); // Some(3.14)
+     * Str.parse.float("42");   // Some(42)
+     * Str.parse.float("abc");  // None
+     * ```
+     */
+    float: (s) => {
+      const n = parseFloat(s);
+      return isNaN(n) ? Option.none() : Option.some(n);
+    }
+  };
+})(Str || (Str = {}));
+
+// src/Utils/Uniq.ts
+var Uniq;
+((Uniq2) => {
+  Uniq2.empty = () => new globalThis.Set();
+  Uniq2.singleton = (item) => new globalThis.Set([item]);
+  Uniq2.fromArray = (arr) => new globalThis.Set(arr);
+  Uniq2.has = (item) => (s) => s.has(item);
+  Uniq2.size = (s) => s.size;
+  Uniq2.isEmpty = (s) => s.size === 0;
+  Uniq2.isSubsetOf = (other) => (s) => {
+    const set = s;
+    if (typeof set.isSubsetOf === "function") return set.isSubsetOf(other);
+    for (const item of s) {
+      if (!other.has(item)) return false;
+    }
+    return true;
+  };
+  Uniq2.insert = (item) => (s) => {
+    if (s.has(item)) return s;
+    const result = new globalThis.Set(s);
+    result.add(item);
+    return result;
+  };
+  Uniq2.remove = (item) => (s) => {
+    if (!s.has(item)) return s;
+    const result = new globalThis.Set(s);
+    result.delete(item);
+    return result;
+  };
+  Uniq2.map = (f) => (s) => {
+    const result = new globalThis.Set();
+    for (const item of s) {
+      result.add(f(item));
+    }
+    return result;
+  };
+  Uniq2.filter = (predicate) => (s) => {
+    const result = new globalThis.Set();
+    for (const item of s) {
+      if (predicate(item)) result.add(item);
+    }
+    return result;
+  };
+  Uniq2.union = (other) => (s) => {
+    const set = s;
+    if (typeof set.union === "function") return set.union(other);
+    const result = new globalThis.Set(s);
+    for (const item of other) result.add(item);
+    return result;
+  };
+  Uniq2.intersection = (other) => (s) => {
+    const set = s;
+    if (typeof set.intersection === "function") return set.intersection(other);
+    const result = new globalThis.Set();
+    for (const item of s) if (other.has(item)) result.add(item);
+    return result;
+  };
+  Uniq2.difference = (other) => (s) => {
+    const set = s;
+    if (typeof set.difference === "function") return set.difference(other);
+    const result = new globalThis.Set();
+    for (const item of s) if (!other.has(item)) result.add(item);
+    return result;
+  };
+  Uniq2.reduce = (init, f) => (s) => {
+    let acc = init;
+    for (const item of s) {
+      acc = f(acc, item);
+    }
+    return acc;
+  };
+  Uniq2.toArray = (s) => [...s];
+})(Uniq || (Uniq = {}));
+export {
+  Arr,
+  Dict,
+  Num,
+  Rec,
+  Str,
+  Uniq
+};

package/package.json

@@ -1,71 +1,65 @@
 {
-  "name": "@nlozgachev/pipelined",
-  "version": "0.11.0",
-  "description": "Simple functional programming toolkit for TypeScript",
-  "keywords": [
-    "functional",
-    "fp",
-    "typescript",
-    "composition",
-    "pipe"
-  ],
-  "homepage": "https://pipelined.lozgachev.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/nlozgachev/pipelined"
-  },
-  "license": "BSD-3-Clause",
-  "types": "./types/mod.d.ts",
-  "exports": {
-    "./composition": {
-      "import": {
-        "types": "./types/src/Composition/index.d.ts",
-        "default": "./esm/src/Composition/index.js"
-      },
-      "require": {
-        "types": "./types/src/Composition/index.d.ts",
-        "default": "./script/src/Composition/index.js"
-      }
-    },
-    "./core": {
-      "import": {
-        "types": "./types/src/Core/index.d.ts",
-        "default": "./esm/src/Core/index.js"
-      },
-      "require": {
-        "types": "./types/src/Core/index.d.ts",
-        "default": "./script/src/Core/index.js"
-      }
-    },
-    "./utils": {
-      "import": {
-        "types": "./types/src/Utils/index.d.ts",
-        "default": "./esm/src/Utils/index.js"
-      },
-      "require": {
-        "types": "./types/src/Utils/index.d.ts",
-        "default": "./script/src/Utils/index.js"
-      }
-    },
-    "./types": {
-      "import": {
-        "types": "./types/src/Types/index.d.ts",
-        "default": "./esm/src/Types/index.js"
-      },
-      "require": {
-        "types": "./types/src/Types/index.d.ts",
-        "default": "./script/src/Types/index.js"
-      }
-    }
-  },
-  "scripts": {},
-  "sideEffects": false,
-  "engines": {
-    "node": ">=22"
-  },
-  "files": [
-    "esm",
-    "script",
-    "types"
-  ]
+	"name": "@nlozgachev/pipelined",
+	"version": "0.13.0",
+	"description": "Simple functional programming toolkit for TypeScript",
+	"license": "BSD-3-Clause",
+	"homepage": "https://pipelined.lozgachev.dev",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nlozgachev/pipelined.git"
+	},
+	"keywords": [
+		"functional",
+		"fp",
+		"typescript",
+		"composition",
+		"pipe"
+	],
+	"sideEffects": false,
+	"engines": {
+		"node": ">=22"
+	},
+	"files": [
+		"dist"
+	],
+	"exports": {
+		"./composition": {
+			"types": "./dist/composition.d.ts",
+			"import": "./dist/composition.mjs",
+			"require": "./dist/composition.cjs"
+		},
+		"./core": {
+			"types": "./dist/core.d.ts",
+			"import": "./dist/core.mjs",
+			"require": "./dist/core.cjs"
+		},
+		"./utils": {
+			"types": "./dist/utils.d.ts",
+			"import": "./dist/utils.mjs",
+			"require": "./dist/utils.cjs"
+		},
+		"./types": {
+			"types": "./dist/types.d.ts",
+			"import": "./dist/types.mjs",
+			"require": "./dist/types.cjs"
+		}
+	},
+	"scripts": {
+		"test": "vitest run",
+		"bench": "vitest bench",
+		"build": "tsup",
+		"format": "dprint fmt",
+		"format:check": "dprint check",
+		"typecheck": "tsc --noEmit",
+		"lint": "oxlint src/",
+		"publish:npm": "pnpm build && npm publish --access public"
+	},
+	"devDependencies": {
+		"@types/node": "25.5.0",
+		"dprint": "0.53.0",
+		"oxlint": "1.56.0",
+		"tsup": "8.5.1",
+		"typescript": "5.9.3",
+		"vitest": "4.1.0"
+	}
 }

package/esm/mod.js

@@ -1,3 +0,0 @@
-export * from "./src/Composition/index.js";
-export * from "./src/Core/index.js";
-export * from "./src/Composition/index.js";

package/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/esm/src/Composition/compose.js

@@ -1,3 +0,0 @@
-export function compose(...fns) {
-    return (arg) => fns.reduceRight((acc, fn) => fn(acc), arg);
-}