@jesscss/awaitable-pipe 2.0.0-alpha.5 → 2.0.0-alpha.6

package/lib/index.cjs

@@ -0,0 +1,214 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/utils.ts
+function isThenable(x) {
+	return !!x && (typeof x === "object" || typeof x === "function") && "then" in x && typeof x.then === "function";
+}
+function isPromise(x) {
+	return !!x && typeof x === "object" && "then" in x && typeof x.then === "function" && "catch" in x && 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.
+*/
+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);
+		})();
+	}
+}
+/**
+* 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.
+*/
+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;
+}
+//#endregion
+//#region src/pipe.ts
+function isAnyFn(value) {
+	return typeof value === "function";
+}
+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;
+}
+function pipe(...args) {
+	let input;
+	let fns;
+	if (args.length === 0) return;
+	const first = args[0];
+	const second = args[1];
+	const rest = args.slice(1);
+	if (isAnyFn(first) && isAnyFn(second)) {
+		input = void 0;
+		fns = args.filter(isAnyFn);
+	} else if (args.length > 1) {
+		input = isAnyFn(first) ? first(void 0) : first;
+		fns = rest.filter(isAnyFn);
+	} else {
+		input = void 0;
+		if (!isAnyFn(first)) return first;
+		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 isFallbackFactory(fallback) {
+	return typeof fallback === "function";
+}
+function resolveFallback(fb) {
+	return isFallbackFactory(fb) ? fb() : fb;
+}
+function runAsyncSafe(v, fns, startIndex, opts) {
+	const { onError, fallback } = opts;
+	const callOnError = (e) => {
+		try {
+			onError?.(e);
+		} catch {}
+	};
+	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);
+	});
+}
+function safePipe(...args) {
+	let input;
+	let options;
+	let fns;
+	if (args.length === 0) return;
+	const first = args[0];
+	const second = args[1];
+	const looksLikeOptions = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+	if (args.length === 1 && !!first && typeof first === "object") return;
+	const bothFns = isAnyFn(first) && isAnyFn(second);
+	if (looksLikeOptions(first) || bothFns) {
+		input = void 0;
+		options = looksLikeOptions(first) ? first : {};
+		fns = (looksLikeOptions(first) ? args.slice(1) : args).filter(isAnyFn);
+	} else throw new TypeError("safePipe requires steps-only or options-first with steps");
+	input = void 0;
+	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;
+}
+//#endregion
+//#region src/helpers.ts
+function resolveStepFallback(fallback, error, input) {
+	return typeof fallback === "function" ? fallback(error, input) : fallback;
+}
+function isNoArgFunction(fn) {
+	return fn.length === 0;
+}
+function tryStep(fn, options = {}) {
+	if (isNoArgFunction(fn)) {
+		const noInputFn = fn;
+		const resultFn = (input) => {
+			try {
+				const out = noInputFn();
+				if (isThenable(out)) return out.catch((e) => {
+					try {
+						options.onError?.(e, input);
+					} catch (_onErrorThrown) {}
+					if (options.rethrow === true) return Promise.reject(e);
+					return resolveStepFallback(options.fallback, e, input);
+				});
+				return out;
+			} catch (e) {
+				try {
+					options.onError?.(e, input);
+				} catch (_onErrorThrown) {}
+				if (options.rethrow === true) throw e;
+				return resolveStepFallback(options.fallback, e, input);
+			}
+		};
+		return resultFn;
+	}
+	return (input) => {
+		try {
+			const out = fn(input);
+			if (isThenable(out)) return out.catch((e) => {
+				try {
+					options.onError?.(e, input);
+				} catch (_onErrorThrown) {}
+				if (options.rethrow === true) return Promise.reject(e);
+				return resolveStepFallback(options.fallback, e, input);
+			});
+			return out;
+		} catch (e) {
+			try {
+				options.onError?.(e, input);
+			} catch (_onErrorThrown) {}
+			if (options.rethrow === true) throw e;
+			return resolveStepFallback(options.fallback, e, input);
+		}
+	};
+}
+function guard(predicate, errorFactory = (_v) => /* @__PURE__ */ 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;
+	};
+}
+//#endregion
+exports.guard = guard;
+exports.isPromise = isPromise;
+exports.isThenable = isThenable;
+exports.pipe = pipe;
+exports.safePipe = safePipe;
+exports.serialForEach = serialForEach;
+exports.serialReduce = serialReduce;
+exports.tryStep = tryStep;

package/lib/index.d.cts

@@ -0,0 +1,63 @@
+//#region src/pipe.d.ts
+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;
+declare function pipe<A, R1>(fn1: () => A, fn2: (a: Unwrap<A>) => R1): PipeResult<undefined, [() => A, (a: Unwrap<A>) => R1]>;
+declare function pipe<A, R1>(fn1: (a?: A) => R1): PipeResult<undefined, [(a?: A) => R1]>;
+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]>;
+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]>;
+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]>;
+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]>;
+declare function pipe<T, R1>(input: T | Promise<T> | (() => T) | (() => Promise<T>), fn1: (a: Unwrap<T>) => R1): PipeResult<T, [(a: Unwrap<T>) => R1]>;
+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]>;
+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]>;
+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]>;
+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]>;
+declare function pipe<A>(input: A | Promise<A> | (() => A) | (() => Promise<A>), ...fns: Array<(a: A) => A | Promise<A>>): A | Promise<A>;
+type SafePipeOptions<R = unknown> = {
+  onError?: (error: unknown) => void;
+  fallback?: R | (() => R);
+};
+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;
+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;
+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;
+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;
+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;
+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;
+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;
+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;
+//#endregion
+//#region src/utils.d.ts
+type MaybePromise<T> = T | Promise<T>;
+declare function isThenable(x: unknown): x is Promise<unknown>;
+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.
+*/
+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.
+*/
+declare function serialReduce<T, A>(items: readonly T[], seed: A, step: (acc: A, item: T, index: number) => MaybePromise<A>): MaybePromise<A>;
+//#endregion
+//#region src/helpers.d.ts
+type StepErrorOptions<TIn, R> = {
+  onError?: (error: unknown, input: TIn) => void;
+  fallback?: R | ((error: unknown, input: TIn) => R);
+  rethrow?: boolean;
+};
+declare function tryStep<TIn, R>(fn: (input: TIn) => MaybePromise<R>, options: StepErrorOptions<TIn, R> & {
+  rethrow: true;
+}): (input: TIn) => MaybePromise<R>;
+declare function tryStep<R>(fn: () => MaybePromise<R>, options: StepErrorOptions<undefined, R> & {
+  rethrow: true;
+}): () => MaybePromise<R>;
+declare function tryStep<R>(fn: () => MaybePromise<R>, options?: StepErrorOptions<undefined, R | undefined>): () => MaybePromise<R | undefined>;
+declare function tryStep<TIn, R>(fn: (input: TIn) => MaybePromise<R>, options?: StepErrorOptions<TIn, R | undefined>): (input: TIn) => MaybePromise<R | undefined>;
+declare function guard<T>(predicate: (value: T) => MaybePromise<boolean>, errorFactory?: (value: T) => unknown): (value: T) => MaybePromise<T>;
+//#endregion
+export { type MaybePromise, type SafePipeOptions, guard, isPromise, isThenable, pipe, safePipe, serialForEach, serialReduce, tryStep };

package/lib/index.d.ts

@@ -1,5 +1,63 @@
-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';
+//#region src/pipe.d.ts
+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;
+declare function pipe<A, R1>(fn1: () => A, fn2: (a: Unwrap<A>) => R1): PipeResult<undefined, [() => A, (a: Unwrap<A>) => R1]>;
+declare function pipe<A, R1>(fn1: (a?: A) => R1): PipeResult<undefined, [(a?: A) => R1]>;
+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]>;
+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]>;
+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]>;
+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]>;
+declare function pipe<T, R1>(input: T | Promise<T> | (() => T) | (() => Promise<T>), fn1: (a: Unwrap<T>) => R1): PipeResult<T, [(a: Unwrap<T>) => R1]>;
+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]>;
+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]>;
+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]>;
+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]>;
+declare function pipe<A>(input: A | Promise<A> | (() => A) | (() => Promise<A>), ...fns: Array<(a: A) => A | Promise<A>>): A | Promise<A>;
+type SafePipeOptions<R = unknown> = {
+  onError?: (error: unknown) => void;
+  fallback?: R | (() => R);
+};
+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;
+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;
+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;
+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;
+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;
+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;
+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;
+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;
+//#endregion
+//#region src/utils.d.ts
+type MaybePromise<T> = T | Promise<T>;
+declare function isThenable(x: unknown): x is Promise<unknown>;
+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.
+*/
+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.
+*/
+declare function serialReduce<T, A>(items: readonly T[], seed: A, step: (acc: A, item: T, index: number) => MaybePromise<A>): MaybePromise<A>;
+//#endregion
+//#region src/helpers.d.ts
+type StepErrorOptions<TIn, R> = {
+  onError?: (error: unknown, input: TIn) => void;
+  fallback?: R | ((error: unknown, input: TIn) => R);
+  rethrow?: boolean;
+};
+declare function tryStep<TIn, R>(fn: (input: TIn) => MaybePromise<R>, options: StepErrorOptions<TIn, R> & {
+  rethrow: true;
+}): (input: TIn) => MaybePromise<R>;
+declare function tryStep<R>(fn: () => MaybePromise<R>, options: StepErrorOptions<undefined, R> & {
+  rethrow: true;
+}): () => MaybePromise<R>;
+declare function tryStep<R>(fn: () => MaybePromise<R>, options?: StepErrorOptions<undefined, R | undefined>): () => MaybePromise<R | undefined>;
+declare function tryStep<TIn, R>(fn: (input: TIn) => MaybePromise<R>, options?: StepErrorOptions<TIn, R | undefined>): (input: TIn) => MaybePromise<R | undefined>;
+declare function guard<T>(predicate: (value: T) => MaybePromise<boolean>, errorFactory?: (value: T) => unknown): (value: T) => MaybePromise<T>;
+//#endregion
+export { type MaybePromise, type SafePipeOptions, guard, isPromise, isThenable, pipe, safePipe, serialForEach, serialReduce, tryStep };

package/lib/index.js

@@ -1,4 +1,206 @@
-export { pipe, safePipe } from './pipe.js';
-export { tryStep, guard, serialForEach, serialReduce } from './helpers.js';
-export { isThenable, isPromise } from './utils.js';
-//# sourceMappingURL=index.js.map
+//#region src/utils.ts
+function isThenable(x) {
+	return !!x && (typeof x === "object" || typeof x === "function") && "then" in x && typeof x.then === "function";
+}
+function isPromise(x) {
+	return !!x && typeof x === "object" && "then" in x && typeof x.then === "function" && "catch" in x && 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.
+*/
+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);
+		})();
+	}
+}
+/**
+* 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.
+*/
+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;
+}
+//#endregion
+//#region src/pipe.ts
+function isAnyFn(value) {
+	return typeof value === "function";
+}
+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;
+}
+function pipe(...args) {
+	let input;
+	let fns;
+	if (args.length === 0) return;
+	const first = args[0];
+	const second = args[1];
+	const rest = args.slice(1);
+	if (isAnyFn(first) && isAnyFn(second)) {
+		input = void 0;
+		fns = args.filter(isAnyFn);
+	} else if (args.length > 1) {
+		input = isAnyFn(first) ? first(void 0) : first;
+		fns = rest.filter(isAnyFn);
+	} else {
+		input = void 0;
+		if (!isAnyFn(first)) return first;
+		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 isFallbackFactory(fallback) {
+	return typeof fallback === "function";
+}
+function resolveFallback(fb) {
+	return isFallbackFactory(fb) ? fb() : fb;
+}
+function runAsyncSafe(v, fns, startIndex, opts) {
+	const { onError, fallback } = opts;
+	const callOnError = (e) => {
+		try {
+			onError?.(e);
+		} catch {}
+	};
+	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);
+	});
+}
+function safePipe(...args) {
+	let input;
+	let options;
+	let fns;
+	if (args.length === 0) return;
+	const first = args[0];
+	const second = args[1];
+	const looksLikeOptions = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+	if (args.length === 1 && !!first && typeof first === "object") return;
+	const bothFns = isAnyFn(first) && isAnyFn(second);
+	if (looksLikeOptions(first) || bothFns) {
+		input = void 0;
+		options = looksLikeOptions(first) ? first : {};
+		fns = (looksLikeOptions(first) ? args.slice(1) : args).filter(isAnyFn);
+	} else throw new TypeError("safePipe requires steps-only or options-first with steps");
+	input = void 0;
+	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;
+}
+//#endregion
+//#region src/helpers.ts
+function resolveStepFallback(fallback, error, input) {
+	return typeof fallback === "function" ? fallback(error, input) : fallback;
+}
+function isNoArgFunction(fn) {
+	return fn.length === 0;
+}
+function tryStep(fn, options = {}) {
+	if (isNoArgFunction(fn)) {
+		const noInputFn = fn;
+		const resultFn = (input) => {
+			try {
+				const out = noInputFn();
+				if (isThenable(out)) return out.catch((e) => {
+					try {
+						options.onError?.(e, input);
+					} catch (_onErrorThrown) {}
+					if (options.rethrow === true) return Promise.reject(e);
+					return resolveStepFallback(options.fallback, e, input);
+				});
+				return out;
+			} catch (e) {
+				try {
+					options.onError?.(e, input);
+				} catch (_onErrorThrown) {}
+				if (options.rethrow === true) throw e;
+				return resolveStepFallback(options.fallback, e, input);
+			}
+		};
+		return resultFn;
+	}
+	return (input) => {
+		try {
+			const out = fn(input);
+			if (isThenable(out)) return out.catch((e) => {
+				try {
+					options.onError?.(e, input);
+				} catch (_onErrorThrown) {}
+				if (options.rethrow === true) return Promise.reject(e);
+				return resolveStepFallback(options.fallback, e, input);
+			});
+			return out;
+		} catch (e) {
+			try {
+				options.onError?.(e, input);
+			} catch (_onErrorThrown) {}
+			if (options.rethrow === true) throw e;
+			return resolveStepFallback(options.fallback, e, input);
+		}
+	};
+}
+function guard(predicate, errorFactory = (_v) => /* @__PURE__ */ 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;
+	};
+}
+//#endregion
+export { guard, isPromise, isThenable, pipe, safePipe, serialForEach, serialReduce, tryStep };

package/package.json

@@ -1,20 +1,16 @@
 {
   "name": "@jesscss/awaitable-pipe",
-  "version": "2.0.0-alpha.5",
+  "version": "2.0.0-alpha.6",
   "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",
+  "main": "lib/index.cjs",
   "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"
+      "source": "./src/index.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.cjs"
     },
     "./package.json": "./package.json"
   },
@@ -44,11 +40,13 @@
   "devDependencies": {
     "typescript": "~5.8.2"
   },
+  "module": "lib/index.js",
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "dev": "tsc -w -p tsconfig.build.json",
+    "build": "pnpm compile",
+    "dev": "tsdown --tsconfig tsconfig.build.json --watch",
     "test": "vitest run",
     "test:types": "tsc -p tsconfig.json --noEmit",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "compile": "tsdown --tsconfig tsconfig.build.json"
   }
 }

package/lib/helpers.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAQzD,wDAAwD;AACxD,SAAS,eAAe,CACtB,EAA+D;IAE/D,OAAO,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC;AACzB,CAAC;AAwBD,MAAM,UAAU,OAAO,CACrB,EAA+D,EAC/D,UAA4D,EAAE;IAE9D,kDAAkD;IAClD,IAAI,eAAe,CAAC,EAAE,CAAC,EAAE,CAAC;QACxB,MAAM,SAAS,GAAG,EAAE,CAAC,CAAC,mDAAmD;QACzE,4FAA4F;QAC5F,kCAAkC;QAClC,MAAM,QAAQ,GAAG,CAAC,KAAW,EAAE,EAAE;YAC/B,IAAI,CAAC;gBACH,MAAM,GAAG,GAAG,SAAS,EAAE,CAAC;gBACxB,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;oBACpB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,CAAU,EAAE,EAAE;wBAC9B,IAAI,CAAC;4BACH,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,KAAwB,CAAC,CAAC;wBACjD,CAAC;wBAAC,OAAO,aAAa,EAAE,CAAC;4BACvB,kDAAkD;wBACpD,CAAC;wBACD,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;4BAC7B,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;wBAC3B,CAAC;wBACD,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;wBAC5B,OAAO,OAAO,EAAE,KAAK,UAAU,CAAC,CAAC,CAAE,EAA4C,CAAC,CAAC,EAAE,KAAwB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;oBACpH,CAAC,CAAgC,CAAC;gBACpC,CAAC;gBACD,OAAO,GAAG,CAAC;YACb,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,IAAI,CAAC;oBACH,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,KAAwB,CAAC,CAAC;gBACjD,CAAC;gBAAC,OAAO,aAAa,EAAE,CAAC;oBACvB,kDAAkD;gBACpD,CAAC;gBACD,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;oBAC7B,MAAM,CAAC,CAAC;gBACV,CAAC;gBACD,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;gBAC5B,OAAO,OAAO,EAAE,KAAK,UAAU,CAAC,CAAC,CAAE,EAA4C,CAAC,CAAC,EAAE,KAAwB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACpH,CAAC;QACH,CAAC,CAAC;QACF,sCAAsC;QACtC,sGAAsG;QACtG,gFAAgF;QAChF,uEAAuE;QACvE,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC7B,wFAAwF;YACxF,OAAO,QAA4C,CAAC;QACtD,CAAC;QACD,OAAO,QAAwD,CAAC;IAClE,CAAC;IACD,wDAAwD;IACxD,MAAM,OAAO,GAAG,EAAqC,CAAC;IACtD,OAAO,CAAC,KAAU,EAAE,EAAE;QACpB,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;YACtB,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBACpB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,CAAU,EAAE,EAAE;oBAC9B,IAAI,CAAC;wBACH,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;oBAC9B,CAAC;oBAAC,OAAO,aAAa,EAAE,CAAC;wBACvB,kDAAkD;oBACpD,CAAC;oBACD,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;wBAC7B,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;oBAC3B,CAAC;oBACD,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;oBAC5B,OAAO,OAAO,EAAE,KAAK,UAAU,CAAC,CAAC,CAAE,EAAgC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBACrF,CAAC,CAAC,CAAC;YACL,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC;gBACH,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAC9B,CAAC;YAAC,OAAO,aAAa,EAAE,CAAC;gBACvB,kDAAkD;YACpD,CAAC;YACD,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;gBAC7B,MAAM,CAAC,CAAC;YACV,CAAC;YACD,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC;YAC5B,OAAO,OAAO,EAAE,KAAK,UAAU,CAAC,CAAC,CAAE,EAAgC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACrF,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,KAAK,CACnB,SAA8C,EAC9C,eAAsC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,KAAK,CAAC,eAAe,CAAC;IAEvE,OAAO,CAAC,KAAQ,EAAE,EAAE;QAClB,MAAM,EAAE,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,UAAU,CAAC,EAAE,CAAC,EAAE,CAAC;YACnB,OAAO,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;gBACtB,IAAI,CAAC,MAAM,EAAE,CAAC;oBACZ,MAAM,YAAY,CAAC,KAAK,CAAC,CAAC;gBAC5B,CAAC;gBACD,OAAO,KAAK,CAAC;YACf,CAAC,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,MAAM,YAAY,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;AACJ,CAAC"}

package/lib/index.js.map

@@ -1 +0,0 @@
-{"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

@@ -1,32 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

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

package/lib/utils.d.ts

@@ -1,13 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}