@philiprehberger/pipe 0.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 philiprehberger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# @philiprehberger/pipe
+
+[![CI](https://github.com/philiprehberger/ts-pipe/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/ts-pipe/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/@philiprehberger/pipe.svg)](https://www.npmjs.com/package/@philiprehberger/pipe)
+[![License](https://img.shields.io/github/license/philiprehberger/ts-pipe)](LICENSE)
+
+Typed functional pipe and compose for TypeScript
+
+## Installation
+
+```bash
+npm install @philiprehberger/pipe
+```
+
+## Usage
+
+```ts
+import { pipe, pipeline, pipeAsync } from '@philiprehberger/pipe';
+
+const result = pipe(" Hello ", s => s.trim(), s => s.split(" "));
+// string[] — fully inferred
+
+const transform = pipeline(s => s.trim(), s => s.toLowerCase());
+transform(" HELLO "); // "hello"
+
+const data = await pipeAsync(userId, fetchUser, extractProfile, validate);
+```
+
+### Compose (right-to-left)
+
+```ts
+import { compose } from '@philiprehberger/pipe';
+
+const format = compose(
+  (s: string) => `[${s}]`,
+  (s: string) => s.toUpperCase(),
+  (s: string) => s.trim(),
+);
+format("  hello  "); // "[HELLO]"
+```
+
+## API
+
+| Function | Description |
+|----------|-------------|
+| `pipe(value, ...fns)` | Data-first pipeline, returns final result |
+| `compose(...fns)` | Right-to-left function composition |
+| `pipeline(...fns)` | Left-to-right composition, returns reusable function |
+| `pipeAsync(value, ...fns)` | Async-aware pipeline with await between steps |
+
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+// src/pipe.ts
+function pipe(value, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), value);
+}
+
+// src/compose.ts
+function compose(...fns) {
+  return (arg) => fns.reduceRight((acc, fn) => fn(acc), arg);
+}
+
+// src/pipeline.ts
+function pipeline(...fns) {
+  return (arg) => fns.reduce((acc, fn) => fn(acc), arg);
+}
+
+// src/pipe-async.ts
+async function pipeAsync(value, ...fns) {
+  let result = value;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+
+exports.compose = compose;
+exports.pipe = pipe;
+exports.pipeAsync = pipeAsync;
+exports.pipeline = pipeline;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pipe.ts","../src/compose.ts","../src/pipeline.ts","../src/pipe-async.ts"],"names":[],"mappings":";;;AAUO,SAAS,IAAA,CAAK,UAAmB,GAAA,EAA6C;AACnF,EAAA,OAAO,GAAA,CAAI,OAAO,CAAC,GAAA,EAAK,OAAO,EAAA,CAAG,GAAG,GAAG,KAAK,CAAA;AAC/C;;;ACPO,SAAS,WAAW,GAAA,EAA+D;AACxF,EAAA,OAAO,CAAC,GAAA,KAAiB,GAAA,CAAI,WAAA,CAAY,CAAC,KAAK,EAAA,KAAO,EAAA,CAAG,GAAG,CAAA,EAAG,GAAG,CAAA;AACpE;;;ACFO,SAAS,YAAY,GAAA,EAA+D;AACzF,EAAA,OAAO,CAAC,GAAA,KAAiB,GAAA,CAAI,MAAA,CAAO,CAAC,KAAK,EAAA,KAAO,EAAA,CAAG,GAAG,CAAA,EAAG,GAAG,CAAA;AAC/D;;;ACDA,eAAsB,SAAA,CAAU,UAAmB,GAAA,EAAyE;AAC1H,EAAA,IAAI,MAAA,GAAS,KAAA;AACb,EAAA,KAAA,MAAW,MAAM,GAAA,EAAK;AACpB,IAAA,MAAA,GAAS,MAAM,GAAG,MAAM,CAAA;AAAA,EAC1B;AACA,EAAA,OAAO,MAAA;AACT","file":"index.cjs","sourcesContent":["export function pipe<A>(value: A): A;\nexport function pipe<A, B>(value: A, fn1: (a: A) => B): B;\nexport function pipe<A, B, C>(value: A, fn1: (a: A) => B, fn2: (b: B) => C): C;\nexport function pipe<A, B, C, D>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H, fn8: (h: H) => I): I;\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H, fn8: (h: H) => I, fn9: (i: I) => J): J;\nexport function pipe(value: unknown, ...fns: ((arg: unknown) => unknown)[]): unknown {\n  return fns.reduce((acc, fn) => fn(acc), value);\n}\n","export function compose<A, B>(fn1: (a: A) => B): (a: A) => B;\nexport function compose<A, B, C>(fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => C;\nexport function compose<A, B, C, D>(fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => D;\nexport function compose<A, B, C, D, E>(fn4: (d: D) => E, fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => E;\nexport function compose<A, B, C, D, E, F>(fn5: (e: E) => F, fn4: (d: D) => E, fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => F;\nexport function compose(...fns: ((arg: unknown) => unknown)[]): (arg: unknown) => unknown {\n  return (arg: unknown) => fns.reduceRight((acc, fn) => fn(acc), arg);\n}\n","export function pipeline<A, B>(fn1: (a: A) => B): (a: A) => B;\nexport function pipeline<A, B, C>(fn1: (a: A) => B, fn2: (b: B) => C): (a: A) => C;\nexport function pipeline<A, B, C, D>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): (a: A) => D;\nexport function pipeline<A, B, C, D, E>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): (a: A) => E;\nexport function pipeline<A, B, C, D, E, F>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): (a: A) => F;\nexport function pipeline(...fns: ((arg: unknown) => unknown)[]): (arg: unknown) => unknown {\n  return (arg: unknown) => fns.reduce((acc, fn) => fn(acc), arg);\n}\n","export function pipeAsync<A>(value: A): Promise<A>;\nexport function pipeAsync<A, B>(value: A, fn1: (a: A) => B | Promise<B>): Promise<B>;\nexport function pipeAsync<A, B, C>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>): Promise<C>;\nexport function pipeAsync<A, B, C, D>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>): Promise<D>;\nexport function pipeAsync<A, B, C, D, E>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>): Promise<E>;\nexport function pipeAsync<A, B, C, D, E, F>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>, fn5: (e: E) => F | Promise<F>): Promise<F>;\nexport async function pipeAsync(value: unknown, ...fns: ((arg: unknown) => unknown | Promise<unknown>)[]): Promise<unknown> {\n  let result = value;\n  for (const fn of fns) {\n    result = await fn(result);\n  }\n  return result;\n}\n"]}

package/dist/index.d.cts

@@ -0,0 +1,31 @@
+declare function pipe<A>(value: A): A;
+declare function pipe<A, B>(value: A, fn1: (a: A) => B): B;
+declare function pipe<A, B, C>(value: A, fn1: (a: A) => B, fn2: (b: B) => C): C;
+declare function pipe<A, B, C, D>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): D;
+declare function pipe<A, B, C, D, E>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): E;
+declare function pipe<A, B, C, D, E, F>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): F;
+declare function pipe<A, B, C, D, E, F, G>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G): G;
+declare function pipe<A, B, C, D, E, F, G, H>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H): H;
+declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H, fn8: (h: H) => I): I;
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H, fn8: (h: H) => I, fn9: (i: I) => J): J;
+
+declare function compose<A, B>(fn1: (a: A) => B): (a: A) => B;
+declare function compose<A, B, C>(fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => C;
+declare function compose<A, B, C, D>(fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => D;
+declare function compose<A, B, C, D, E>(fn4: (d: D) => E, fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => E;
+declare function compose<A, B, C, D, E, F>(fn5: (e: E) => F, fn4: (d: D) => E, fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => F;
+
+declare function pipeline<A, B>(fn1: (a: A) => B): (a: A) => B;
+declare function pipeline<A, B, C>(fn1: (a: A) => B, fn2: (b: B) => C): (a: A) => C;
+declare function pipeline<A, B, C, D>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): (a: A) => D;
+declare function pipeline<A, B, C, D, E>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): (a: A) => E;
+declare function pipeline<A, B, C, D, E, F>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): (a: A) => F;
+
+declare function pipeAsync<A>(value: A): Promise<A>;
+declare function pipeAsync<A, B>(value: A, fn1: (a: A) => B | Promise<B>): Promise<B>;
+declare function pipeAsync<A, B, C>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>): Promise<C>;
+declare function pipeAsync<A, B, C, D>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>): Promise<D>;
+declare function pipeAsync<A, B, C, D, E>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>): Promise<E>;
+declare function pipeAsync<A, B, C, D, E, F>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>, fn5: (e: E) => F | Promise<F>): Promise<F>;
+
+export { compose, pipe, pipeAsync, pipeline };

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+declare function pipe<A>(value: A): A;
+declare function pipe<A, B>(value: A, fn1: (a: A) => B): B;
+declare function pipe<A, B, C>(value: A, fn1: (a: A) => B, fn2: (b: B) => C): C;
+declare function pipe<A, B, C, D>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): D;
+declare function pipe<A, B, C, D, E>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): E;
+declare function pipe<A, B, C, D, E, F>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): F;
+declare function pipe<A, B, C, D, E, F, G>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G): G;
+declare function pipe<A, B, C, D, E, F, G, H>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H): H;
+declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H, fn8: (h: H) => I): I;
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H, fn8: (h: H) => I, fn9: (i: I) => J): J;
+
+declare function compose<A, B>(fn1: (a: A) => B): (a: A) => B;
+declare function compose<A, B, C>(fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => C;
+declare function compose<A, B, C, D>(fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => D;
+declare function compose<A, B, C, D, E>(fn4: (d: D) => E, fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => E;
+declare function compose<A, B, C, D, E, F>(fn5: (e: E) => F, fn4: (d: D) => E, fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => F;
+
+declare function pipeline<A, B>(fn1: (a: A) => B): (a: A) => B;
+declare function pipeline<A, B, C>(fn1: (a: A) => B, fn2: (b: B) => C): (a: A) => C;
+declare function pipeline<A, B, C, D>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): (a: A) => D;
+declare function pipeline<A, B, C, D, E>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): (a: A) => E;
+declare function pipeline<A, B, C, D, E, F>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): (a: A) => F;
+
+declare function pipeAsync<A>(value: A): Promise<A>;
+declare function pipeAsync<A, B>(value: A, fn1: (a: A) => B | Promise<B>): Promise<B>;
+declare function pipeAsync<A, B, C>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>): Promise<C>;
+declare function pipeAsync<A, B, C, D>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>): Promise<D>;
+declare function pipeAsync<A, B, C, D, E>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>): Promise<E>;
+declare function pipeAsync<A, B, C, D, E, F>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>, fn5: (e: E) => F | Promise<F>): Promise<F>;
+
+export { compose, pipe, pipeAsync, pipeline };

package/dist/index.js

@@ -0,0 +1,27 @@
+// src/pipe.ts
+function pipe(value, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), value);
+}
+
+// src/compose.ts
+function compose(...fns) {
+  return (arg) => fns.reduceRight((acc, fn) => fn(acc), arg);
+}
+
+// src/pipeline.ts
+function pipeline(...fns) {
+  return (arg) => fns.reduce((acc, fn) => fn(acc), arg);
+}
+
+// src/pipe-async.ts
+async function pipeAsync(value, ...fns) {
+  let result = value;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+
+export { compose, pipe, pipeAsync, pipeline };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pipe.ts","../src/compose.ts","../src/pipeline.ts","../src/pipe-async.ts"],"names":[],"mappings":";AAUO,SAAS,IAAA,CAAK,UAAmB,GAAA,EAA6C;AACnF,EAAA,OAAO,GAAA,CAAI,OAAO,CAAC,GAAA,EAAK,OAAO,EAAA,CAAG,GAAG,GAAG,KAAK,CAAA;AAC/C;;;ACPO,SAAS,WAAW,GAAA,EAA+D;AACxF,EAAA,OAAO,CAAC,GAAA,KAAiB,GAAA,CAAI,WAAA,CAAY,CAAC,KAAK,EAAA,KAAO,EAAA,CAAG,GAAG,CAAA,EAAG,GAAG,CAAA;AACpE;;;ACFO,SAAS,YAAY,GAAA,EAA+D;AACzF,EAAA,OAAO,CAAC,GAAA,KAAiB,GAAA,CAAI,MAAA,CAAO,CAAC,KAAK,EAAA,KAAO,EAAA,CAAG,GAAG,CAAA,EAAG,GAAG,CAAA;AAC/D;;;ACDA,eAAsB,SAAA,CAAU,UAAmB,GAAA,EAAyE;AAC1H,EAAA,IAAI,MAAA,GAAS,KAAA;AACb,EAAA,KAAA,MAAW,MAAM,GAAA,EAAK;AACpB,IAAA,MAAA,GAAS,MAAM,GAAG,MAAM,CAAA;AAAA,EAC1B;AACA,EAAA,OAAO,MAAA;AACT","file":"index.js","sourcesContent":["export function pipe<A>(value: A): A;\nexport function pipe<A, B>(value: A, fn1: (a: A) => B): B;\nexport function pipe<A, B, C>(value: A, fn1: (a: A) => B, fn2: (b: B) => C): C;\nexport function pipe<A, B, C, D>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): E;\nexport function pipe<A, B, C, D, E, F>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): F;\nexport function pipe<A, B, C, D, E, F, G>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G): G;\nexport function pipe<A, B, C, D, E, F, G, H>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H, fn8: (h: H) => I): I;\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F, fn6: (f: F) => G, fn7: (g: G) => H, fn8: (h: H) => I, fn9: (i: I) => J): J;\nexport function pipe(value: unknown, ...fns: ((arg: unknown) => unknown)[]): unknown {\n  return fns.reduce((acc, fn) => fn(acc), value);\n}\n","export function compose<A, B>(fn1: (a: A) => B): (a: A) => B;\nexport function compose<A, B, C>(fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => C;\nexport function compose<A, B, C, D>(fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => D;\nexport function compose<A, B, C, D, E>(fn4: (d: D) => E, fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => E;\nexport function compose<A, B, C, D, E, F>(fn5: (e: E) => F, fn4: (d: D) => E, fn3: (c: C) => D, fn2: (b: B) => C, fn1: (a: A) => B): (a: A) => F;\nexport function compose(...fns: ((arg: unknown) => unknown)[]): (arg: unknown) => unknown {\n  return (arg: unknown) => fns.reduceRight((acc, fn) => fn(acc), arg);\n}\n","export function pipeline<A, B>(fn1: (a: A) => B): (a: A) => B;\nexport function pipeline<A, B, C>(fn1: (a: A) => B, fn2: (b: B) => C): (a: A) => C;\nexport function pipeline<A, B, C, D>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D): (a: A) => D;\nexport function pipeline<A, B, C, D, E>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E): (a: A) => E;\nexport function pipeline<A, B, C, D, E, F>(fn1: (a: A) => B, fn2: (b: B) => C, fn3: (c: C) => D, fn4: (d: D) => E, fn5: (e: E) => F): (a: A) => F;\nexport function pipeline(...fns: ((arg: unknown) => unknown)[]): (arg: unknown) => unknown {\n  return (arg: unknown) => fns.reduce((acc, fn) => fn(acc), arg);\n}\n","export function pipeAsync<A>(value: A): Promise<A>;\nexport function pipeAsync<A, B>(value: A, fn1: (a: A) => B | Promise<B>): Promise<B>;\nexport function pipeAsync<A, B, C>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>): Promise<C>;\nexport function pipeAsync<A, B, C, D>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>): Promise<D>;\nexport function pipeAsync<A, B, C, D, E>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>): Promise<E>;\nexport function pipeAsync<A, B, C, D, E, F>(value: A, fn1: (a: A) => B | Promise<B>, fn2: (b: B) => C | Promise<C>, fn3: (c: C) => D | Promise<D>, fn4: (d: D) => E | Promise<E>, fn5: (e: E) => F | Promise<F>): Promise<F>;\nexport async function pipeAsync(value: unknown, ...fns: ((arg: unknown) => unknown | Promise<unknown>)[]): Promise<unknown> {\n  let result = value;\n  for (const fn of fns) {\n    result = await fn(result);\n  }\n  return result;\n}\n"]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@philiprehberger/pipe",
+  "version": "0.1.4",
+  "description": "Typed functional pipe and compose for TypeScript",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "test": "node --test"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "pipe",
+    "compose",
+    "pipeline",
+    "functional",
+    "chain",
+    "transform"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/philiprehberger/ts-pipe.git"
+  },
+  "homepage": "https://github.com/philiprehberger/ts-pipe#readme",
+  "bugs": {
+    "url": "https://github.com/philiprehberger/ts-pipe/issues"
+  },
+  "author": "Philip Rehberger",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "sideEffects": false
+}