@jesscss/awaitable-pipe 2.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) Matthew Dean
+
+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,185 @@
+# awaitable-pipe
+
+![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)
+
+A tiny, zero-dependency pipe with friendly types that “just works”: it stays sync when everything is sync, and turns into a Promise only when something is async. No wrappers, no ceremony.
+
+- **Stays sync when it can**: all-sync pipelines return a plain value
+- **Goes async when it must**: any async input/step returns a Promise
+- **One place for errors**: `safePipe` gives you a single `onError` + optional `fallback`
+- **Steps-only API**: start with an initializer step (() => value | Promise), or omit it entirely
+- **Typed nicely**: TypeScript keeps the sync/async shape without Result-like wrappers
+
+## Install
+
+```bash
+pnpm add @jesscss/awaitable-pipe
+# or
+npm i @jesscss/awaitable-pipe
+```
+
+## Quick Start
+
+```ts
+import { pipe, safePipe } from '@jesscss/awaitable-pipe';
+
+// Sync stays sync
+const upper = (s: string) => s.toUpperCase();
+const exclaim = (s: string) => s + '!';
+const out = pipe(() => 'ok', upper, exclaim);   // 'OK!'
+
+// Mixed becomes Promise
+const load = async (s: string) => s + '!';
+const outP = pipe(() => 'ok', upper, load);     // Promise<string>
+const result = await outP;                // 'OK!'
+
+// Start without an initial value
+const s2 = pipe((x?: number) => (x ?? 2) * 3); // 6
+
+// Single-point error handling (never throws)
+const boom = () => { throw new Error('nope'); };
+const safe = safePipe({ onError: console.error, fallback: 'X' }, () => 'ok', boom, upper);
+// 'X'
+```
+
+## Why would you want this?
+JavaScript Promises are great, but they aren’t free. Every async hop schedules work, allocates objects, and pushes errors across an async boundary. In hot paths, that overhead can add up.
+
+That said, consider this a micro-optimization! This is really only a faster approach than forced async / await when a very small percentage of unknown function calls result in Promises (< 10% of steps returning Promises in performance testing). If a greater percentage of steps would normally return promises, then using an async / await pattern on all unknown results (regardless of whether or not those results are a Promise, which JavaScript is fine with) will generally be faster than using this library.
+
+### Features
+
+- **Zero extra overhead for sync work**: when your steps are synchronous, you get plain values—no microtasks, no `await`, no extra Promise allocations.
+- **Seamless async when you need it**: if any step is async, the pipeline naturally promotes to a Promise—no special handling required.
+- **Cleaner stacks**: sync-only flows keep straightforward stack traces and easier debugging.
+- **Simple error strategy**: prefer natural throw/reject with `pipe`, or centralize it once with `safePipe` without wrapping results.
+
+## API
+
+### pipe(...steps)
+- **Return shape**: sync returns a value; any async → Promise
+- **Errors**: sync errors throw; async errors reject
+- **Inputs**: value, Promise, thunk (() => value|Promise), or omit (first step gets `undefined`)
+
+```ts
+// compose sync functions → string
+const a = pipe(() => 'hi', (s) => s.trim(), (s) => s.toUpperCase());
+
+// mix in async → Promise<string>
+const b = pipe(() => 'hi', async (s) => s + '!', (s) => s + '?');
+
+// no initial value
+const c = pipe((x?: number) => (x ?? 1) + 1, (n) => n * 10); // 20
+```
+
+### safePipe(options, ...steps)
+If you prefer not to throw or reject, `safePipe` centralizes error handling. You get an optional `onError` callback and a `fallback` value (or thunk). On error, the pipeline returns the fallback (or `undefined` if you didn’t provide one).
+
+- **Never throws**: errors are caught and routed to `onError`
+- **Return shape preserved**: still sync-if-sync, async-if-async
+- **Start forms**: options-first (no explicit initial value) or steps-only
+
+```ts
+// Sync-only path
+const r1 = safePipe({ onError: console.warn, fallback: 'X' }, () => 'ok', (s: string) => s.toUpperCase()); // 'OK'
+
+// Sync error → fallback
+const r2 = safePipe({ onError: console.warn, fallback: 'X' },
+  () => { throw new Error('boom'); },
+  (s: string) => s.toUpperCase()
+); // 'X'
+
+// Async path → Promise<string>
+const r3 = await safePipe({ onError: console.warn, fallback: 'X' },
+  () => 'ok',
+  async (s: string) => s + '!',
+  (s: string) => s + '?'
+); // 'ok!?'
+
+// No fallback provided. On error, returns undefined (never throws).
+const r5 = safePipe({ onError: console.warn },
+  () => { throw new Error('boom'); },
+  (s: string) => s.toUpperCase()
+); // undefined
+```
+
+## Composing pipes
+You can feed the output of one pipe (value or Promise) into another. Types keep up with you.
+
+```ts
+const p1 = pipe(() => 'hi', (s: string) => s.toUpperCase()); // string
+const p2 = pipe(() => p1, (s) => s + '!');                   // 'HI!'
+
+const p3 = pipe(() => 'hi', async s => s + '!');             // Promise<string>
+const p4 = pipe(() => p3, (s) => s + '?');                   // Promise<string>
+const fin = await p4;                                        // 'hi!?'
+```
+
+## Per-step helpers
+Sometimes you want to guard or handle errors at a specific step without switching the whole pipeline to safe mode. Use these helpers as steps inside `pipe` or `safePipe`:
+
+```ts
+import { pipe, tryStep, guard, serialForEach, serialReduce } from '@jesscss/awaitable-pipe';
+
+// tryStep: catch at this step only, with optional onError and fallback
+const step = tryStep((n: number) => {
+  if (n < 0) throw new Error('no negatives');
+  return n * 2;
+}, {
+  onError: (err, n) => console.warn('bad number:', n, err),
+  fallback: 0 // could also be (err, n) => 0
+});
+
+const out = pipe(() => 5, step);   // 10
+const out2 = pipe(() => -1, step); // 0
+
+// onError can throw to rethrow the error (or a transformed error) for upstream handling
+const stepWithRethrow = tryStep((input: string) => {
+  if (input === 'bad') throw new ReferenceError('not found');
+  return input.toUpperCase();
+}, {
+  onError: (error, input) => {
+    // Conditionally rethrow based on error type
+    if (error instanceof ReferenceError) {
+      throw error; // Re-throw for upstream handling
+    }
+    // Otherwise, just log - fallback will be used
+    console.log('Handled error:', error);
+  },
+  fallback: 'default'
+});
+
+const result1 = pipe(() => 'good', stepWithRethrow); // 'GOOD'
+const result2 = pipe(() => 'bad', stepWithRethrow);  // Throws ReferenceError
+const result3 = pipe(() => 'other', stepWithRethrow); // 'default' (if step throws non-ReferenceError)
+
+// Or use rethrow: true to always rethrow after onError
+const alwaysRethrow = tryStep((n: number) => {
+  if (n < 0) throw new Error('no negatives');
+  return n * 2;
+}, {
+  onError: (err, n) => console.warn('Error:', err),
+  rethrow: true // Always rethrow the original error after onError
+});
+
+// guard: ensure a condition holds at this step (sync or async)
+const positive = guard((n: number) => n > 0, (n) => new Error(`not positive: ${n}`));
+const ok = pipe(() => 3, positive);         // 3
+// pipe(() => -2, positive) would throw: Error('not positive: -2')
+
+// serialForEach: sync-first loop that promotes to async if a step returns a Promise
+const items = [1, 2, 3];
+await serialForEach(items, async (n, i) => {
+  if (i === 1) await new Promise(r => setTimeout(r, 10));
+});
+
+// serialReduce: sync-first reduce that promotes to async on demand
+const sum = await serialReduce(items, 0, async (acc, n, i) => {
+  if (i === 2) await Promise.resolve();
+  return acc + n;
+});
+// sum === 6
+```
+
+## License
+MIT

package/lib/helpers.d.ts

@@ -0,0 +1,16 @@
+import type { MaybePromise } from './utils.js';
+export { serialForEach, serialReduce } from './utils.js';
+export type StepErrorOptions<TIn, R> = {
+    onError?: (error: unknown, input: TIn) => void;
+    fallback?: R | ((error: unknown, input: TIn) => R);
+    rethrow?: boolean;
+};
+export declare function tryStep<TIn, R>(fn: (input: TIn) => MaybePromise<R>, options: StepErrorOptions<TIn, R> & {
+    rethrow: true;
+}): (input: TIn) => MaybePromise<R>;
+export declare function tryStep<R>(fn: () => MaybePromise<R>, options: StepErrorOptions<undefined, R> & {
+    rethrow: true;
+}): () => MaybePromise<R>;
+export declare function tryStep<R>(fn: () => MaybePromise<R>, options?: StepErrorOptions<undefined, R | undefined>): () => MaybePromise<R | undefined>;
+export declare function tryStep<TIn, R>(fn: (input: TIn) => MaybePromise<R>, options?: StepErrorOptions<TIn, R | undefined>): (input: TIn) => MaybePromise<R | undefined>;
+export declare function guard<T>(predicate: (value: T) => MaybePromise<boolean>, errorFactory?: (value: T) => unknown): (value: T) => MaybePromise<T>;

package/lib/helpers.js

@@ -0,0 +1,111 @@
+import { isThenable } from './utils.js';
+export { serialForEach, serialReduce } from './utils.js';
+// Type guard to help TypeScript narrow no-arg functions
+function isNoArgFunction(fn) {
+    return fn.length === 0;
+}
+export function tryStep(fn, options = {}) {
+    // Check if fn takes no arguments (for first step)
+    if (isNoArgFunction(fn)) {
+        const noInputFn = fn; // Type guard narrows this to () => MaybePromise<R>
+        // Even though the function takes no args, the wrapper should accept input for pipe chaining
+        // and pass it to fallback/onError
+        const resultFn = (input) => {
+            try {
+                const out = noInputFn();
+                if (isThenable(out)) {
+                    return out.catch((e) => {
+                        try {
+                            options.onError?.(e, input);
+                        }
+                        catch (onErrorThrown) {
+                            // Swallow onError errors and continue to fallback
+                        }
+                        if (options.rethrow === true) {
+                            return Promise.reject(e);
+                        }
+                        const fb = options.fallback;
+                        return typeof fb === 'function' ? fb(e, input) : fb;
+                    });
+                }
+                return out;
+            }
+            catch (e) {
+                try {
+                    options.onError?.(e, input);
+                }
+                catch (onErrorThrown) {
+                    // Swallow onError errors and continue to fallback
+                }
+                if (options.rethrow === true) {
+                    throw e;
+                }
+                const fb = options.fallback;
+                return typeof fb === 'function' ? fb(e, input) : fb;
+            }
+        };
+        // Cast to match overload return types
+        // Overloads say () => MaybePromise<R>, but implementation accepts optional input for fallback/onError
+        // At runtime, JavaScript allows calling () => A with an argument, so this works
+        // TypeScript sees () => MaybePromise<R> to match pipe's first overload
+        if (options.rethrow === true) {
+            // Type assertion: TypeScript sees () => MaybePromise<R>, runtime accepts optional input
+            return resultFn;
+        }
+        return resultFn;
+    }
+    // Original implementation for functions that take input
+    const inputFn = fn;
+    return (input) => {
+        try {
+            const out = fn(input);
+            if (isThenable(out)) {
+                return out.catch((e) => {
+                    try {
+                        options.onError?.(e, input);
+                    }
+                    catch (onErrorThrown) {
+                        // Swallow onError errors and continue to fallback
+                    }
+                    if (options.rethrow === true) {
+                        return Promise.reject(e);
+                    }
+                    const fb = options.fallback;
+                    return typeof fb === 'function' ? fb(e, input) : fb;
+                });
+            }
+            return out;
+        }
+        catch (e) {
+            try {
+                options.onError?.(e, input);
+            }
+            catch (onErrorThrown) {
+                // Swallow onError errors and continue to fallback
+            }
+            if (options.rethrow === true) {
+                throw e;
+            }
+            const fb = options.fallback;
+            return typeof fb === 'function' ? fb(e, input) : fb;
+        }
+    };
+}
+export function guard(predicate, errorFactory = (v) => new Error('ensure failed')) {
+    return (value) => {
+        const ok = predicate(value);
+        if (isThenable(ok)) {
+            return ok.then(passed => {
+                if (!passed) {
+                    throw errorFactory(value);
+                }
+                return value;
+            });
+        }
+        if (!ok) {
+            throw errorFactory(value);
+        }
+        return value;
+    };
+}
+//# sourceMappingURL=helpers.js.map

package/lib/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"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"}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export type { SafePipeOptions } from './pipe.js';
+export { pipe, safePipe } from './pipe.js';
+export { tryStep, guard, serialForEach, serialReduce } from './helpers.js';
+export type { MaybePromise } from './utils.js';
+export { isThenable, isPromise } from './utils.js';

package/lib/index.js

@@ -0,0 +1,4 @@
+export { pipe, safePipe } from './pipe.js';
+export { tryStep, guard, serialForEach, serialReduce } from './helpers.js';
+export { isThenable, isPromise } from './utils.js';
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE3E,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/lib/pipe.d.ts

@@ -0,0 +1,32 @@
+type Unwrap<T> = T extends Promise<infer U> ? U : T;
+type RetOf<F> = F extends (a: any) => infer R ? R : never;
+type ParamOf<F> = F extends (...args: infer P) => any ? (P extends [infer A, ...any[]] ? A : never) : never;
+type Apply<In, F> = [
+    ParamOf<F>
+] extends [never] ? RetOf<F> : In extends Promise<any> ? Promise<Awaited<RetOf<F>>> : RetOf<F>;
+type PipeResult<In, Fns extends any[], Acc = In> = Fns extends [infer F, ...infer Rest] ? PipeResult<Apply<Acc, F>, Rest> : Acc;
+export declare function pipe<A, R1>(fn1: () => A, fn2: (a: Unwrap<A>) => R1): PipeResult<undefined, [() => A, (a: Unwrap<A>) => R1]>;
+export declare function pipe<A, R1>(fn1: (a?: A) => R1): PipeResult<undefined, [(a?: A) => R1]>;
+export declare function pipe<A, R1, R2>(fn1: () => A, fn2: (a: Unwrap<A>) => R1, fn3: (b: Unwrap<R1>) => R2): PipeResult<undefined, [() => A, (a: Unwrap<A>) => R1, (b: Unwrap<R1>) => R2]>;
+export declare function pipe<A, R1, R2, R3>(fn1: () => A, fn2: (a: Unwrap<A>) => R1, fn3: (b: Unwrap<R1>) => R2, fn4: (c: Unwrap<R2>) => R3): PipeResult<undefined, [() => A, (a: Unwrap<A>) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3]>;
+export declare function pipe<A, R1, R2, R3, R4>(fn1: () => A, fn2: (a: Unwrap<A>) => R1, fn3: (b: Unwrap<R1>) => R2, fn4: (c: Unwrap<R2>) => R3, fn5: (d: Unwrap<R3>) => R4): PipeResult<undefined, [() => A, (a: Unwrap<A>) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3, (d: Unwrap<R3>) => R4]>;
+export declare function pipe<A, R1, R2, R3, R4, R5>(fn1: () => A, fn2: (a: Unwrap<A>) => R1, fn3: (b: Unwrap<R1>) => R2, fn4: (c: Unwrap<R2>) => R3, fn5: (d: Unwrap<R3>) => R4, fn6: (e: Unwrap<R4>) => R5): PipeResult<undefined, [() => A, (a: Unwrap<A>) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3, (d: Unwrap<R3>) => R4, (e: Unwrap<R4>) => R5]>;
+export declare function pipe<T, R1>(input: T | Promise<T> | (() => T) | (() => Promise<T>), fn1: (a: Unwrap<T>) => R1): PipeResult<T, [(a: Unwrap<T>) => R1]>;
+export declare function pipe<T, R1, R2>(input: T | Promise<T> | (() => T) | (() => Promise<T>), fn1: (a: Unwrap<T>) => R1, fn2: (b: Unwrap<R1>) => R2): PipeResult<T, [(a: Unwrap<T>) => R1, (b: Unwrap<R1>) => R2]>;
+export declare function pipe<T, R1, R2, R3>(input: T | Promise<T> | (() => T) | (() => Promise<T>), fn1: (a: Unwrap<T>) => R1, fn2: (b: Unwrap<R1>) => R2, fn3: (c: Unwrap<R2>) => R3): PipeResult<T, [(a: Unwrap<T>) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3]>;
+export declare function pipe<T, R1, R2, R3, R4>(input: T | Promise<T> | (() => T) | (() => Promise<T>), fn1: (a: Unwrap<T>) => R1, fn2: (b: Unwrap<R1>) => R2, fn3: (c: Unwrap<R2>) => R3, fn4: (d: Unwrap<R3>) => R4): PipeResult<T, [(a: Unwrap<T>) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3, (d: Unwrap<R3>) => R4]>;
+export declare function pipe<T, R1, R2, R3, R4, R5>(input: T | Promise<T> | (() => T) | (() => Promise<T>), fn1: (a: Unwrap<T>) => R1, fn2: (b: Unwrap<R1>) => R2, fn3: (c: Unwrap<R2>) => R3, fn4: (d: Unwrap<R3>) => R4, fn5: (e: Unwrap<R4>) => R5): PipeResult<T, [(a: Unwrap<T>) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3, (d: Unwrap<R3>) => R4, (e: Unwrap<R4>) => R5]>;
+export declare function pipe<A>(input: A | Promise<A> | (() => A) | (() => Promise<A>), ...fns: Array<(a: A) => A | Promise<A>>): A | Promise<A>;
+export type SafePipeOptions<R = unknown> = {
+    onError?: (error: unknown) => void;
+    fallback?: R | (() => R);
+};
+export declare function safePipe<A, R1>(options: SafePipeOptions<any>, fn1: (a?: A) => R1): PipeResult<undefined, [(a?: A) => R1]> extends Promise<any> ? Promise<R1 | undefined> : R1 | undefined;
+export declare function safePipe<A, R1, R2>(options: SafePipeOptions<any>, fn1: (a?: A) => R1, fn2: (b: Unwrap<R1>) => R2): PipeResult<undefined, [(a?: A) => R1, (b: Unwrap<R1>) => R2]> extends Promise<any> ? Promise<R2 | undefined> : R2 | undefined;
+export declare function safePipe<A, R1, R2, R3>(options: SafePipeOptions<any>, fn1: (a?: A) => R1, fn2: (b: Unwrap<R1>) => R2, fn3: (c: Unwrap<R2>) => R3): PipeResult<undefined, [(a?: A) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3]> extends Promise<any> ? Promise<R3 | undefined> : R3 | undefined;
+export declare function safePipe<A, R1>(fn1: () => A, fn2: (a: A) => R1): PipeResult<undefined, [() => A, (a: A) => R1]> extends Promise<any> ? Promise<R1 | undefined> : R1 | undefined;
+export declare function safePipe<A, R1, R2>(fn1: () => A, fn2: (a: A) => R1, fn3: (b: Unwrap<R1>) => R2): PipeResult<undefined, [() => A, (a: A) => R1, (b: Unwrap<R1>) => R2]> extends Promise<any> ? Promise<R2 | undefined> : R2 | undefined;
+export declare function safePipe<A, R1, R2, R3>(fn1: () => A, fn2: (a: A) => R1, fn3: (b: Unwrap<R1>) => R2, fn4: (c: Unwrap<R2>) => R3): PipeResult<undefined, [() => A, (a: A) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3]> extends Promise<any> ? Promise<R3 | undefined> : R3 | undefined;
+export declare function safePipe<A, R1, R2, R3, R4>(fn1: () => A, fn2: (a: A) => R1, fn3: (b: Unwrap<R1>) => R2, fn4: (c: Unwrap<R2>) => R3, fn5: (d: Unwrap<R3>) => R4): PipeResult<undefined, [() => A, (a: A) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3, (d: Unwrap<R3>) => R4]> extends Promise<any> ? Promise<R4 | undefined> : R4 | undefined;
+export declare function safePipe<A, R1, R2, R3, R4, R5>(fn1: () => A, fn2: (a: A) => R1, fn3: (b: Unwrap<R1>) => R2, fn4: (c: Unwrap<R2>) => R3, fn5: (d: Unwrap<R3>) => R4, fn6: (e: Unwrap<R4>) => R5): PipeResult<undefined, [() => A, (a: A) => R1, (b: Unwrap<R1>) => R2, (c: Unwrap<R2>) => R3, (d: Unwrap<R3>) => R4, (e: Unwrap<R4>) => R5]> extends Promise<any> ? Promise<R5 | undefined> : R5 | undefined;
+export {};

package/lib/pipe.js

@@ -0,0 +1,126 @@
+import { isThenable } from './utils.js';
+function runAsync(v, fns, startIndex) {
+    let p = Promise.resolve(v);
+    for (let i = startIndex; i < fns.length; i++) {
+        const fn = fns[i];
+        p = p.then(val => fn(val));
+    }
+    return p;
+}
+// Note: Intentionally omitting generic varargs overloads to improve contextual typing
+export function pipe(...args) {
+    let input;
+    let fns;
+    if (args.length === 0)
+        return undefined;
+    const first = args[0];
+    const second = args[1];
+    const rest = args.slice(1);
+    // Disambiguation:
+    // - If first and second are both functions → treat as steps-only (no explicit input)
+    // - Else if more than one arg → treat first as input (value | Promise | thunk)
+    // - Else single function → steps-only
+    const stepsOnly = typeof first === 'function' && typeof second === 'function';
+    if (stepsOnly) {
+        input = undefined;
+        fns = args;
+    }
+    else if (args.length > 1) {
+        input = typeof first === 'function' ? first() : first;
+        fns = rest;
+    }
+    else {
+        input = undefined;
+        fns = [first];
+    }
+    if (isThenable(input)) {
+        return runAsync(input, fns, 0);
+    }
+    for (let i = 0; i < fns.length; i++) {
+        const fn = fns[i];
+        const out = fn(input);
+        if (isThenable(out)) {
+            return runAsync(out, fns, i + 1);
+        }
+        input = out;
+    }
+    return input;
+}
+function resolveFallback(fb) {
+    return typeof fb === 'function' ? fb() : fb;
+}
+function runAsyncSafe(v, fns, startIndex, opts) {
+    const { onError, fallback } = opts;
+    const callOnError = (e) => {
+        try {
+            onError?.(e);
+        }
+        catch {
+            // Swallow errors from onError to keep guarantees: never throw
+        }
+    };
+    let p = Promise.resolve(v);
+    for (let i = startIndex; i < fns.length; i++) {
+        const fn = fns[i];
+        p = p.then(val => {
+            try {
+                return fn(val);
+            }
+            catch (e) {
+                callOnError(e);
+                return resolveFallback(fallback);
+            }
+        }, e => {
+            callOnError(e);
+            return resolveFallback(fallback);
+        });
+    }
+    return p.catch(e => {
+        callOnError(e);
+        return resolveFallback(fallback);
+    });
+}
+export function safePipe(...args) {
+    let input;
+    let options;
+    let fns;
+    if (args.length === 0)
+        return undefined;
+    const first = args[0];
+    const second = args[1];
+    const looksLikeOptions = (x) => !!x && typeof x === 'object' && !Array.isArray(x);
+    // Special-case: options-first with no steps should return undefined
+    if (args.length === 1 && !!first && typeof first === 'object') {
+        return undefined;
+    }
+    const bothFns = typeof first === 'function' && typeof second === 'function';
+    if (looksLikeOptions(first) || bothFns) {
+        // options-first or steps-only (no explicit input)
+        input = undefined;
+        options = looksLikeOptions(first) ? first : {};
+        fns = (looksLikeOptions(first) ? args.slice(1) : args);
+    }
+    else {
+        throw new TypeError('safePipe requires steps-only or options-first with steps');
+    }
+    input = undefined;
+    for (let i = 0; i < fns.length; i++) {
+        const fn = fns[i];
+        try {
+            const out = fn(input);
+            if (isThenable(out)) {
+                return runAsyncSafe(out, fns, i + 1, options);
+            }
+            input = out;
+        }
+        catch (e) {
+            try {
+                options?.onError?.(e);
+            }
+            catch { }
+            return resolveFallback(options?.fallback);
+        }
+    }
+    return input;
+}
+//# sourceMappingURL=pipe.js.map

package/lib/pipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.js","sourceRoot":"","sources":["../src/pipe.ts"],"names":[],"mappings":"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"}

package/lib/utils.d.ts

@@ -0,0 +1,13 @@
+export type MaybePromise<T> = T | Promise<T>;
+export declare function isThenable(x: unknown): x is Promise<unknown>;
+export declare function isPromise<T = unknown>(x: unknown): x is Promise<T>;
+/**
+ * Serial forEach over an array where the step may return a Promise.
+ * Runs synchronously until an async step is encountered, then switches to async for the remainder.
+ */
+export declare function serialForEach<T>(items: readonly T[], step: (item: T, index: number) => MaybePromise<void | undefined>): MaybePromise<void | undefined>;
+/**
+ * Serial reduce over an array where the step may return a Promise.
+ * Runs synchronously until an async step is encountered, then switches to async for the remainder.
+ */
+export declare function serialReduce<T, A>(items: readonly T[], seed: A, step: (acc: A, item: T, index: number) => MaybePromise<A>): MaybePromise<A>;

package/lib/utils.js

@@ -0,0 +1,47 @@
+export function isThenable(x) {
+    return !!x && (typeof x === 'object' || typeof x === 'function') && typeof x.then === 'function';
+}
+export function isPromise(x) {
+    return !!x && typeof x === 'object' && typeof x.then === 'function' && typeof x.catch === 'function';
+}
+/**
+ * Serial forEach over an array where the step may return a Promise.
+ * Runs synchronously until an async step is encountered, then switches to async for the remainder.
+ */
+export function serialForEach(items, step) {
+    for (let i = 0; i < items.length; i++) {
+        const out = step(items[i], i);
+        if (isThenable(out)) {
+            return (async () => {
+                await out;
+                for (let j = i + 1; j < items.length; j++) {
+                    await step(items[j], j);
+                }
+                return undefined;
+            })();
+        }
+    }
+    return undefined;
+}
+/**
+ * Serial reduce over an array where the step may return a Promise.
+ * Runs synchronously until an async step is encountered, then switches to async for the remainder.
+ */
+export function serialReduce(items, seed, step) {
+    let acc = seed;
+    for (let i = 0; i < items.length; i++) {
+        const out = step(acc, items[i], i);
+        if (isThenable(out)) {
+            return (async () => {
+                acc = await out;
+                for (let j = i + 1; j < items.length; j++) {
+                    acc = await step(acc, items[j], j);
+                }
+                return acc;
+            })();
+        }
+        acc = out;
+    }
+    return acc;
+}
+//# sourceMappingURL=utils.js.map

package/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,UAAU,CAAC,CAAU;IACnC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,UAAU,CAAC,IAAI,OAAQ,CAAS,CAAC,IAAI,KAAK,UAAU,CAAC;AAC5G,CAAC;AAED,MAAM,UAAU,SAAS,CAAc,CAAU;IAC/C,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAQ,CAAS,CAAC,IAAI,KAAK,UAAU,IAAI,OAAQ,CAAS,CAAC,KAAK,KAAK,UAAU,CAAC;AACzH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAI,KAAmB,EAAE,IAAgE;IACpH,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAE,EAAE,CAAC,CAAC,CAAC;QAC/B,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACpB,OAAO,CAAC,KAAK,IAAI,EAAE;gBACjB,MAAM,GAAG,CAAC;gBACV,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC1C,MAAM,IAAI,CAAC,KAAK,CAAC,CAAC,CAAE,EAAE,CAAC,CAAC,CAAC;gBAC3B,CAAC;gBACD,OAAO,SAAS,CAAC;YACnB,CAAC,CAAC,EAAE,CAAC;QACP,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAO,KAAmB,EAAE,IAAO,EAAE,IAAyD;IACxH,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAE,EAAE,CAAC,CAAC,CAAC;QACpC,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACpB,OAAO,CAAC,KAAK,IAAI,EAAE;gBACjB,GAAG,GAAG,MAAM,GAAQ,CAAC;gBACrB,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC1C,GAAG,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAE,EAAE,CAAC,CAAM,CAAC;gBAC3C,CAAC;gBACD,OAAO,GAAG,CAAC;YACb,CAAC,CAAC,EAAE,CAAC;QACP,CAAC;QACD,GAAG,GAAG,GAAQ,CAAC;IACjB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@jesscss/awaitable-pipe",
+  "version": "2.0.0-alpha.1",
+  "description": "A tiny, strongly-typed pipe that stays sync when possible and becomes a Promise when needed. With an optional single-point error handler.",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "types": "./lib/index.d.ts",
+      "source": "./src/index.ts"
+    },
+    "./*": {
+      "types": "./lib/*.d.ts",
+      "import": "./lib/*.js",
+      "source": "./src/*.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/matthew-dean/jess.git"
+  },
+  "keywords": [
+    "pipe",
+    "functional",
+    "async",
+    "sync",
+    "typescript",
+    "error-handling"
+  ],
+  "author": "Matthew Dean <matthew-dean@users.noreply.github.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "devDependencies": {
+    "typescript": "~5.8.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -w -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:types": "tsc -p tsconfig.json --noEmit",
+    "test:watch": "vitest"
+  }
+}