typed-pipeline 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ryan Sonshine
+
+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,92 @@
+# typed-pipeline
+
+Type-safe, composable async pipelines for TypeScript.
+
+## Install
+
+```bash
+npm install typed-pipeline
+```
+
+## Usage
+
+```ts
+import { Pipeline } from 'typed-pipeline'
+
+// Basic chaining
+const result = await new Pipeline<number>()
+  .pipe((n) => n * 2)
+  .pipe((n) => `value: ${n}`)
+  .run(5)
+// => "value: 10"
+
+// Async steps
+const result2 = await new Pipeline<string>()
+  .pipe(async (s) => s.trim())
+  .pipe(async (s) => s.toUpperCase())
+  .run('  hello  ')
+// => "HELLO"
+```
+
+## API
+
+### `.pipe(step)`
+Add a transformation step. Input type flows from previous step's output.
+
+```ts
+.pipe((input: TOutput) => TNext)
+```
+
+### `.parallel(...steps)`
+Run multiple steps concurrently, returns a tuple of results.
+
+```ts
+const pipeline = new Pipeline<number>()
+  .parallel(
+    (n) => n + 1,
+    (n) => n * 2,
+    async (n) => n ** 2,
+  )
+
+await pipeline.run(3) // => [4, 6, 9]
+```
+
+### `.bypass(step)` / `.tap(step)`
+Run a side-effect step without changing the value (logging, caching, etc.).
+
+```ts
+new Pipeline<string>()
+  .tap((s) => console.log('input:', s))
+  .pipe((s) => s.toUpperCase())
+  .tap((s) => console.log('output:', s))
+  .run('hello')
+```
+
+### `.saveAs(key)`
+Save the current value under a named key, accessible after `run()`.
+
+```ts
+const pipeline = new Pipeline<number>()
+  .pipe((n) => n * 2).saveAs('doubled')
+  .pipe((n) => n + 1)
+
+await pipeline.run(5)
+pipeline.getResult('doubled') // => 10
+```
+
+### `.getResult(key)`
+Retrieve a value previously saved with `.saveAs()`.
+
+### `.waited()`
+Flatten a nested `Promise<Promise<T>>` to `Promise<T>`.
+
+### `.run(input)`
+Execute the pipeline with the given input.
+
+```ts
+const output = await pipeline.run(input)
+```
+
+## License
+
+MIT

package/lib/fpipe.d.ts

@@ -0,0 +1,59 @@
+/**
+ * fpipe — functional pipe with $$-injection, TS 5.x full type-gymnastics edition
+ *
+ * Features used:
+ *   - `infer X extends Constraint`  (TS 4.8+)
+ *   - Recursive conditional types   (TS 4.1+)
+ *   - Const type parameters         (TS 5.0+)
+ *   - NoInfer<T>                    (TS 5.4+)
+ *   - Variadic tuple types          (TS 4.0+)
+ *   - Labeled tuple elements        (TS 4.0+)
+ *   - Template literal types        (TS 4.1+) — used for error messages
+ */
+type Awaited_<T> = T extends Promise<infer U> ? Awaited_<U> : T;
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Brand that marks "this parameter receives the previous step's output".
+ * The extra `__fpipe_prev__` brand key makes it nominally distinct from plain T.
+ */
+export type Prev<T> = T & {
+    readonly __fpipe_prev__: unique symbol;
+};
+/** A plain unary step: (currentValue: TIn) => TOut */
+type PlainStep<TIn, TOut> = (value: TIn) => MaybePromise<TOut>;
+/**
+ * A $$-aware step: ($$: Prev<TIn>, ...defaults) => TOut
+ * Extra params MUST have defaults so the step is callable as unary at runtime.
+ */
+type PrevStep<TIn, TOut> = ($$: Prev<TIn>, ...rest: DefaultsOnly) => MaybePromise<TOut>;
+/** Ensures extra params all have question marks (i.e. are optional / have defaults). */
+type DefaultsOnly = [] | [first?: unknown, ...rest: (unknown | undefined)[]];
+type AnyStep<TIn = any, TOut = any> = PlainStep<TIn, TOut> | PrevStep<TIn, TOut>;
+/**
+ * Extract the output type of a step, resolving Promise.
+ * Works for both PlainStep and PrevStep (first arg may be Prev<T>).
+ */
+type StepOutput<S> = S extends (arg: any, ...rest: any[]) => MaybePromise<infer O> ? Awaited_<O> : never;
+/**
+ * Extract the *input* type a step expects.
+ * For PrevStep, the first param is Prev<TIn> — unwrap the brand.
+ */
+type StepInput<S> = S extends PlainStep<infer TIn, any> ? TIn : S extends ($$: Prev<infer TIn>, ...rest: any[]) => any ? TIn : never;
+/**
+ * Thread a tuple of steps and build the output type at each position.
+ *
+ * ThreadPipeline<[S1, S2, S3], Seed> =
+ *   [StepOutput<S1>, StepOutput<S2>, StepOutput<S3>]
+ *   where each step's input must match the previous step's output.
+ *
+ * Uses TS5's `infer X extends Constraint` for the head/tail split.
+ */
+type ThreadPipeline<Steps extends readonly AnyStep[], Seed> = Steps extends readonly [] ? Seed : Steps extends readonly [
+    infer Head extends AnyStep,
+    ...infer Tail extends readonly AnyStep[]
+] ? ThreadPipeline<Tail, StepOutput<Head>> : never;
+/** Final output type of a full pipeline */
+type PipelineOutput<Steps extends readonly AnyStep[], Seed> = ThreadPipeline<Steps, Seed>;
+export declare function fpipe<const Steps extends readonly AnyStep[], Seed extends StepInput<Steps[0]>>(...steps: Steps): (input: NoInfer<Seed>) => Promise<PipelineOutput<Steps, Seed>>;
+export type InferOutput<P extends (...args: any[]) => Promise<any>> = P extends (...args: any[]) => Promise<infer O> ? O : never;
+export {};

package/lib/fpipe.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * fpipe — functional pipe with $$-injection, TS 5.x full type-gymnastics edition
+ *
+ * Features used:
+ *   - `infer X extends Constraint`  (TS 4.8+)
+ *   - Recursive conditional types   (TS 4.1+)
+ *   - Const type parameters         (TS 5.0+)
+ *   - NoInfer<T>                    (TS 5.4+)
+ *   - Variadic tuple types          (TS 4.0+)
+ *   - Labeled tuple elements        (TS 4.0+)
+ *   - Template literal types        (TS 4.1+) — used for error messages
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fpipe = fpipe;
+// ─── Implementation ────────────────────────────────────────────────────────────
+function fpipe(...steps) {
+    return async (input) => {
+        let current = input;
+        for (const step of steps) {
+            // $$-aware: fn.length >= 2 → first param is Prev<T>
+            // We call with (current) — extra params use their defaults
+            current = await step(current);
+        }
+        return current;
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export declare const myPackage: (taco?: string) => string;
+export { Pipeline } from './pipeline';
+export { fpipe, type Prev } from './fpipe';

package/lib/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fpipe = exports.Pipeline = exports.myPackage = void 0;
+const myPackage = (taco = '') => `${taco} from my package`;
+exports.myPackage = myPackage;
+var pipeline_1 = require("./pipeline");
+Object.defineProperty(exports, "Pipeline", { enumerable: true, get: function () { return pipeline_1.Pipeline; } });
+var fpipe_1 = require("./fpipe");
+Object.defineProperty(exports, "fpipe", { enumerable: true, get: function () { return fpipe_1.fpipe; } });

package/lib/pipeline.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Pipeline<TInput, TOutput, TSaved>
+ *
+ * Features:
+ *   - .pipe(fn)            — type flows, fn param auto-inferred (no annotation needed)
+ *   - .pipe($$ step)       — first param is Prev<T> ($$-aware), extra params need defaults
+ *   - .pipe((v, $) => ...) — second param is $ accessor: $['key'] gives saved value with type
+ *   - .parallel()          — concurrent steps, returns typed tuple
+ *   - .bypass()/.tap()     — side effects, value passes through
+ *   - .saveAs(key)         — snapshot current value by name, retrieve after run()
+ *   - .inject(key, fn)     — inject one saved value alongside current
+ *   - .withSaved(fn)       — inject all saved values alongside current
+ *   - .waited()            — flatten nested Promise
+ *   - .run(input)          — execute with external seed
+ */
+import { type Prev } from './fpipe';
+type MaybePromise<T> = T | Promise<T>;
+/** Unary step: current value in, next value out */
+type PlainStep<TIn, TOut> = (input: TIn) => MaybePromise<TOut>;
+/**
+ * $$-aware step: first param is Prev<TIn>, extra params must have defaults.
+ * The "$$" name is just convention — any name works.
+ */
+type PrevStep<TIn, TOut> = ($$: Prev<TIn>, ...rest: DefaultsOnly) => MaybePromise<TOut>;
+type DefaultsOnly = any[];
+type SavedResults = Record<string, unknown>;
+/**
+ * Saved-aware step: exactly 2 required params — current value and $ (typed saved accessor).
+ * fn.length === 2 at runtime → distinct from PlainStep (1) and PrevStep (1 + defaults).
+ *
+ * @example
+ * .pipe((n, $) => n + $['doubled'])
+ * .pipe((s, $) => ({ s, original: $['original'], d: $['doubled'] }))
+ */
+type SavedStep<TIn, TOut, TSaved extends SavedResults> = (current: TIn, $: TSaved) => MaybePromise<TOut>;
+type AnyStep<TIn = any, TOut = any> = PlainStep<TIn, TOut> | PrevStep<TIn, TOut> | SavedStep<TIn, TOut, any>;
+type ParallelResults<TSteps extends readonly PlainStep<any, any>[]> = {
+    [K in keyof TSteps]: Awaited<ReturnType<TSteps[K]>>;
+};
+declare class Multicast<T> {
+    private callbacks;
+    emit(value: T): void;
+    subscribe(cb: (value: T) => void): void;
+}
+declare class Job<TInput, TOutput> {
+    private readonly action;
+    private readonly savedResults;
+    readonly after: Multicast<TOutput>;
+    constructor(action: AnyStep<TInput, TOutput>, savedResults?: Map<string, unknown>);
+    run(input: TInput): Promise<TOutput>;
+}
+export declare class Pipeline<TInput, TOutput = TInput, TSaved extends SavedResults = Record<never, never>> {
+    private readonly jobs;
+    private readonly results;
+    private readonly extraResults;
+    constructor(jobs?: Array<Job<any, any>>, results?: Map<string, unknown>, extraResults?: Map<string, unknown>[]);
+    /**
+     * Add a plain step. Parameter type is automatically inferred — no annotation needed.
+     *
+     * @example
+     * new Pipeline<number>()
+     *   .pipe(n => n * 2)       // n inferred as number ✓
+     *   .pipe(n => `val: ${n}`) // n inferred as number ✓
+     *
+     * Or with $$-aware (first param is previous output, extra params need defaults):
+     *   .pipe(($$ , bonus = 3) => $$ + bonus)  // $$ inferred as number ✓
+     */
+    pipe<TNext>(step: SavedStep<TOutput, TNext, TSaved>): Pipeline<TInput, Awaited<TNext>, TSaved>;
+    pipe<TNext>(step: PrevStep<TOutput, TNext>): Pipeline<TInput, Awaited<TNext>, TSaved>;
+    pipe<TNext>(step: PlainStep<TOutput, TNext>): Pipeline<TInput, Awaited<TNext>, TSaved>;
+    /**
+     * Run multiple steps concurrently. Returns a typed tuple.
+     *
+     * @example
+     * .parallel(
+     *   n => n + 1,
+     *   n => n * 2,
+     *   async n => n ** 2,
+     * )
+     * // → [number, number, number]
+     */
+    parallel<TSteps extends readonly PlainStep<TOutput, any>[]>(...steps: TSteps): Pipeline<TInput, ParallelResults<TSteps>, TSaved>;
+    /**
+     * Run a side-effect without changing the value (logging, caching, etc.).
+     *
+     * @example
+     * .tap(n => console.log('current:', n))
+     */
+    bypass(step: (value: TOutput) => MaybePromise<unknown>): Pipeline<TInput, TOutput, TSaved>;
+    tap: (step: (value: TOutput) => MaybePromise<unknown>) => Pipeline<TInput, TOutput, TSaved>;
+    /**
+     * Snapshot the current value under a key. Retrieve after run() with .getResult(key).
+     *
+     * @example
+     * .pipe(n => n * 2).saveAs('doubled')
+     * // pipeline.getResult('doubled') === 10 after run(5)
+     */
+    saveAs<TKey extends string>(key: TKey): Pipeline<TInput, TOutput, TSaved & Record<TKey, TOutput>>;
+    getResult<TKey extends keyof TSaved>(key: TKey): TSaved[TKey] | undefined;
+    /** Flatten a nested Promise<Promise<T>> to Promise<T>. */
+    waited(): Pipeline<TInput, Awaited<TOutput>, TSaved>;
+    /**
+     * Inject a previously saved value alongside the current value.
+     * Both current and saved value are fully typed.
+     *
+     * @example
+     * new Pipeline<number>()
+     *   .pipe(n => n * 2).saveAs('doubled')
+     *   .pipe(n => n + 100)
+     *   .inject('doubled', (current, doubled) => current - doubled)
+     *   // current: number, doubled: number (typed from saveAs)
+     */
+    inject<TKey extends keyof TSaved, TNext>(key: TKey, fn: (current: TOutput, saved: TSaved[TKey]) => MaybePromise<TNext>): Pipeline<TInput, Awaited<TNext>, TSaved>;
+    /**
+     * Access all saved values alongside the current value.
+     * The `saved` object is typed with all previously saved keys.
+     *
+     * @example
+     * new Pipeline<number>()
+     *   .pipe(n => n * 2).saveAs('doubled')
+     *   .pipe(n => n + 1).saveAs('incremented')
+     *   .withSaved((n, saved) => n + saved.doubled + saved.incremented)
+     *   // saved.doubled: number, saved.incremented: number — fully typed
+     */
+    withSaved<TNext>(fn: (current: TOutput, saved: TSaved) => MaybePromise<TNext>): Pipeline<TInput, Awaited<TNext>, TSaved>;
+    /**
+     * Compose two pipelines. The output type of `this` must be assignable to
+     * the input type of `other`.
+     *
+     * @example
+     * const parse  = new Pipeline<string>().pipe(s => parseInt(s))
+     * const double = new Pipeline<number>().pipe(n => n * 2)
+     * const combined = parse.concat(double)
+     * await combined.run('5')  // 10
+     */
+    concat<TNext, TOtherSaved extends SavedResults>(other: Pipeline<TOutput, TNext, TOtherSaved>): Pipeline<TInput, TNext, TSaved & TOtherSaved>;
+    /**
+     * Execute the pipeline with the given input.
+     *
+     * @example
+     * await pipeline.run(5)
+     */
+    run(input: TInput): Promise<TOutput>;
+}
+export {};

package/lib/pipeline.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Pipeline<TInput, TOutput, TSaved>
+ *
+ * Features:
+ *   - .pipe(fn)            — type flows, fn param auto-inferred (no annotation needed)
+ *   - .pipe($$ step)       — first param is Prev<T> ($$-aware), extra params need defaults
+ *   - .pipe((v, $) => ...) — second param is $ accessor: $['key'] gives saved value with type
+ *   - .parallel()          — concurrent steps, returns typed tuple
+ *   - .bypass()/.tap()     — side effects, value passes through
+ *   - .saveAs(key)         — snapshot current value by name, retrieve after run()
+ *   - .inject(key, fn)     — inject one saved value alongside current
+ *   - .withSaved(fn)       — inject all saved values alongside current
+ *   - .waited()            — flatten nested Promise
+ *   - .run(input)          — execute with external seed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pipeline = void 0;
+// ─── Multicast (for saveAs subscriptions) ────────────────────────────────────
+class Multicast {
+    callbacks = [];
+    emit(value) {
+        for (const cb of this.callbacks)
+            cb(value);
+    }
+    subscribe(cb) {
+        this.callbacks.push(cb);
+    }
+}
+// ─── Job ──────────────────────────────────────────────────────────────────────
+class Job {
+    action;
+    savedResults;
+    after = new Multicast();
+    constructor(action, savedResults = new Map()) {
+        this.action = action;
+        this.savedResults = savedResults;
+    }
+    async run(input) {
+        let result;
+        const len = this.action.length;
+        if (len === 2) {
+            // SavedStep: (current, $) — exactly 2 required params
+            const $ = Object.fromEntries(this.savedResults);
+            result = await this.action(input, $);
+        }
+        else if (len >= 2) {
+            // PrevStep with extra defaults beyond 2 (unusual edge case)
+            result = await this.action(input);
+        }
+        else if (len === 1) {
+            // PlainStep OR PrevStep(fn.length===1 because extras have defaults)
+            // Both called with single arg — correct for both
+            result = await this.action(input);
+        }
+        else {
+            // len === 0: no-arg step (e.g. () => value)
+            result = await this.action();
+        }
+        this.after.emit(result);
+        return result;
+    }
+}
+// ─── Pipeline ─────────────────────────────────────────────────────────────────
+class Pipeline {
+    jobs;
+    results;
+    extraResults;
+    constructor(jobs = [], results = new Map(), extraResults = []) {
+        this.jobs = jobs;
+        this.results = results;
+        this.extraResults = extraResults;
+    }
+    // Implementation
+    pipe(step) {
+        return new Pipeline([...this.jobs, new Job(step, this.results)], this.results, this.extraResults);
+    }
+    // ── .parallel() ──────────────────────────────────────────────────────────
+    /**
+     * Run multiple steps concurrently. Returns a typed tuple.
+     *
+     * @example
+     * .parallel(
+     *   n => n + 1,
+     *   n => n * 2,
+     *   async n => n ** 2,
+     * )
+     * // → [number, number, number]
+     */
+    parallel(...steps) {
+        return this.pipe(async (value) => {
+            const results = await Promise.all(steps.map(s => s(value)));
+            return results;
+        });
+    }
+    // ── .bypass() / .tap() ───────────────────────────────────────────────────
+    /**
+     * Run a side-effect without changing the value (logging, caching, etc.).
+     *
+     * @example
+     * .tap(n => console.log('current:', n))
+     */
+    bypass(step) {
+        return this.pipe(async (value) => {
+            await step(value);
+            return value;
+        });
+    }
+    tap = this.bypass.bind(this);
+    // ── .saveAs() ────────────────────────────────────────────────────────────
+    /**
+     * Snapshot the current value under a key. Retrieve after run() with .getResult(key).
+     *
+     * @example
+     * .pipe(n => n * 2).saveAs('doubled')
+     * // pipeline.getResult('doubled') === 10 after run(5)
+     */
+    saveAs(key) {
+        const latestJob = this.jobs[this.jobs.length - 1];
+        if (latestJob == null)
+            throw new Error('saveAs() requires at least one step before it');
+        latestJob.after.subscribe(value => { this.results.set(key, value); });
+        return this;
+    }
+    getResult(key) {
+        const k = key;
+        if (this.results.has(k))
+            return this.results.get(k);
+        for (const m of this.extraResults) {
+            if (m.has(k))
+                return m.get(k);
+        }
+        return undefined;
+    }
+    // ── .waited() ────────────────────────────────────────────────────────────
+    /** Flatten a nested Promise<Promise<T>> to Promise<T>. */
+    waited() {
+        return this.pipe(async (value) => await value);
+    }
+    // ── .inject() ────────────────────────────────────────────────────────────
+    /**
+     * Inject a previously saved value alongside the current value.
+     * Both current and saved value are fully typed.
+     *
+     * @example
+     * new Pipeline<number>()
+     *   .pipe(n => n * 2).saveAs('doubled')
+     *   .pipe(n => n + 100)
+     *   .inject('doubled', (current, doubled) => current - doubled)
+     *   // current: number, doubled: number (typed from saveAs)
+     */
+    inject(key, fn) {
+        return this.pipe(async (current) => {
+            const saved = this.results.get(key);
+            return fn(current, saved);
+        });
+    }
+    // ── .withSaved() ─────────────────────────────────────────────────────────
+    /**
+     * Access all saved values alongside the current value.
+     * The `saved` object is typed with all previously saved keys.
+     *
+     * @example
+     * new Pipeline<number>()
+     *   .pipe(n => n * 2).saveAs('doubled')
+     *   .pipe(n => n + 1).saveAs('incremented')
+     *   .withSaved((n, saved) => n + saved.doubled + saved.incremented)
+     *   // saved.doubled: number, saved.incremented: number — fully typed
+     */
+    withSaved(fn) {
+        return this.pipe(async (current) => {
+            const saved = Object.fromEntries(this.results);
+            return fn(current, saved);
+        });
+    }
+    // ── .concat() ────────────────────────────────────────────────────────────
+    /**
+     * Compose two pipelines. The output type of `this` must be assignable to
+     * the input type of `other`.
+     *
+     * @example
+     * const parse  = new Pipeline<string>().pipe(s => parseInt(s))
+     * const double = new Pipeline<number>().pipe(n => n * 2)
+     * const combined = parse.concat(double)
+     * await combined.run('5')  // 10
+     */
+    concat(other) {
+        // Each pipeline keeps its own results map (saveAs subscriptions are already wired).
+        // The concat'd pipeline holds references to both maps and checks them in getResult.
+        const o = other;
+        return new Pipeline([...this.jobs, ...o.jobs], this.results, [...this.extraResults, o.results, ...o.extraResults]);
+    }
+    // ── .run() ───────────────────────────────────────────────────────────────
+    /**
+     * Execute the pipeline with the given input.
+     *
+     * @example
+     * await pipeline.run(5)
+     */
+    async run(input) {
+        let current = input;
+        for (const job of this.jobs) {
+            current = await job.run(current);
+        }
+        return current;
+    }
+}
+exports.Pipeline = Pipeline;

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "typed-pipeline",
+  "version": "2.0.0",
+  "description": "Type-safe composable async pipelines. Parameters auto-inferred, $$-aware steps, parallel/saveAs/concat.",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./lib/index.js",
+      "import": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "clean": "rm -rf ./lib/",
+    "cm": "cz",
+    "lint": "eslint ./src/ --fix",
+    "semantic-release": "semantic-release",
+    "test:watch": "jest --watch",
+    "test": "jest --coverage",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run clean && npm run build && npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bkmashiro/typed-pipeline.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "baka_mashiro",
+    "email": "bkmashiro@users.noreply.github.com",
+    "url": "https://github.com/bkmashiro"
+  },
+  "engines": {
+    "node": ">=16.0"
+  },
+  "keywords": [
+    "pipeline",
+    "pipe",
+    "compose",
+    "async",
+    "typescript",
+    "type-safe",
+    "functional",
+    "flow",
+    "chain"
+  ],
+  "bugs": {
+    "url": "https://github.com/bkmashiro/typed-pipeline/issues"
+  },
+  "homepage": "https://github.com/bkmashiro/typed-pipeline#readme",
+  "devDependencies": {
+    "@ryansonshine/commitizen": "^4.2.8",
+    "@ryansonshine/cz-conventional-changelog": "^3.3.4",
+    "@types/jest": "^27.5.2",
+    "@types/node": "^12.20.11",
+    "@typescript-eslint/eslint-plugin": "^4.22.0",
+    "@typescript-eslint/parser": "^4.22.0",
+    "conventional-changelog-conventionalcommits": "^5.0.0",
+    "eslint": "^7.25.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^3.4.0",
+    "jest": "^27.2.0",
+    "lint-staged": "^13.2.1",
+    "prettier": "^2.2.1",
+    "semantic-release": "^21.0.1",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.2.1",
+    "typescript": "^5.9.3"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/@ryansonshine/cz-conventional-changelog"
+    }
+  },
+  "lint-staged": {
+    "*.ts": "eslint --cache --cache-location .eslintcache --fix"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "type": "build",
+              "scope": "deps",
+              "release": "patch"
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              { "type": "feat", "section": "Features" },
+              { "type": "fix", "section": "Bug Fixes" },
+              { "type": "build", "section": "Dependencies and Other Build Updates", "hidden": false }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/npm",
+      "@semantic-release/github"
+    ]
+  }
+}