@futpib/parser 1.0.4 → 1.0.6

package/src/terminatedArrayParser.ts

@@ -19,7 +19,7 @@ export const createTerminatedArrayParserNaive = <ElementOutput, TerminatorOutput
 		getParserName(terminatorParser, 'anonymousTerminator'),
 	);
 
-	const elementOrTerminatorParser = createUnionParser<ElementOutput | Terminated<TerminatorOutput>, Sequence>([
+	const elementOrTerminatorParser = createUnionParser([
 		elementParser,
 		promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue)),
 	]);
@@ -51,36 +51,36 @@ export const createTerminatedArrayParser = <ElementOutput, TerminatorOutput, Seq
 		const elements: ElementOutput[] = [];
 
 		while (true) {
-			const terminatorParserContext = parserContext.lookahead({
+			using terminatorParserContext = parserContext.lookahead({
 				debugName: getParserName(terminatorParser, 'anonymousTerminator'),
 			});
 
 			try {
 				const terminatorValue = await terminatorParser(terminatorParserContext);
 
-				const elementParserContext = parserContext.lookahead({
-					debugName: getParserName(elementParser, 'anonymousElement'),
-				});
-
-				try {
-					await elementParser(elementParserContext);
-
-					parserImplementationInvariant(
-						false,
-						[
-							'Both element and terminator parsers matched.',
-							'Element parser: %s',
-							'Terminator parser: %s',
-						],
-						getParserName(elementParser, 'anonymousElement'),
-						getParserName(terminatorParser, 'anonymousTerminator'),
-					);
-				} catch (error) {
-					if (!(isParserParsingFailedError(error))) {
-						throw error;
+				{
+					using elementParserContext = parserContext.lookahead({
+						debugName: getParserName(elementParser, 'anonymousElement'),
+					});
+
+					try {
+						await elementParser(elementParserContext);
+
+						parserImplementationInvariant(
+							false,
+							[
+								'Both element and terminator parsers matched.',
+								'Element parser: %s',
+								'Terminator parser: %s',
+							],
+							getParserName(elementParser, 'anonymousElement'),
+							getParserName(terminatorParser, 'anonymousTerminator'),
+						);
+					} catch (error) {
+						if (!(isParserParsingFailedError(error))) {
+							throw error;
+						}
 					}
-				} finally {
-					elementParserContext.dispose();
 				}
 
 				terminatorParserContext.unlookahead();
@@ -90,8 +90,6 @@ export const createTerminatedArrayParser = <ElementOutput, TerminatorOutput, Seq
 				if (!(isParserParsingFailedError(error))) {
 					throw error;
 				}
-			} finally {
-				terminatorParserContext.dispose();
 			}
 
 			const element = await elementParser(parserContext);
@@ -113,7 +111,7 @@ export const createTerminatedArrayParserUnsafe = <ElementOutput, TerminatorOutpu
 		const elements: ElementOutput[] = [];
 
 		while (true) {
-			const terminatorParserContext = parserContext.lookahead({
+			using terminatorParserContext = parserContext.lookahead({
 				debugName: getParserName(terminatorParser, 'anonymousTerminator'),
 			});
 
@@ -127,8 +125,6 @@ export const createTerminatedArrayParserUnsafe = <ElementOutput, TerminatorOutpu
 				if (!(isParserParsingFailedError(error))) {
 					throw error;
 				}
-			} finally {
-				terminatorParserContext.dispose();
 			}
 
 			const element = await elementParser(parserContext);

package/src/tupleParser.ts

@@ -1,21 +1,24 @@
-import { getParserName, setParserName, type Parser } from './parser.js';
-
-export function createTupleParser<A, B, Sequence>([ parserA, parserB ]: [Parser<A, Sequence>, Parser<B, Sequence>]): Parser<[A, B], Sequence>;
-export function createTupleParser<A, B, C, Sequence>([ parserA, parserB, parserC ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>]): Parser<[A, B, C], Sequence>;
-export function createTupleParser<A, B, C, D, Sequence>([ parserA, parserB, parserC, parserD ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>]): Parser<[A, B, C, D], Sequence>;
-export function createTupleParser<A, B, C, D, E, Sequence>([ parserA, parserB, parserC, parserD, parserE ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>]): Parser<[A, B, C, D, E], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>]): Parser<[A, B, C, D, E, F], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, G, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>]): Parser<[A, B, C, D, E, F, G], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, G, H, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>]): Parser<[A, B, C, D, E, F, G, H], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, G, H, I, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, G, H, I, J, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, N, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM, parserN ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>, Parser<N, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N], Sequence>;
-export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM, parserN, parserO ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>, Parser<N, Sequence>, Parser<O, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O], Sequence>;
-export function createTupleParser<Sequence>(parsers: Array<Parser<unknown, Sequence>>): Parser<unknown[], Sequence> {
-	const tupleParser: Parser<unknown[], Sequence> = async parserContext => {
+import { getParserName, setParserName, type Parser, type ParserOutput, type ParserSequence } from './parser.js';
+
+// Map tuple of parsers to tuple of their outputs
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type TupleParserOutput<Parsers extends readonly Parser<any, any, any>[]> = {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	[K in keyof Parsers]: Parsers[K] extends Parser<any, any, any> ? ParserOutput<Parsers[K]> : never
+};
+
+// Infer Sequence from parser array
+type InferSequenceFromParserArray<T extends readonly unknown[]> = ParserSequence<T[number]>;
+
+export function createTupleParser<
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const Parsers extends readonly Parser<any, any, any>[],
+>(
+	parsers: Parsers,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Parser<TupleParserOutput<Parsers>, InferSequenceFromParserArray<Parsers>, any> {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const tupleParser: Parser<any, any, any> = async parserContext => {
 		const values: unknown[] = [];
 
 		for (const parser of parsers) {

package/src/unionParser.test-d.ts

@@ -0,0 +1,105 @@
+import { expectAssignable, expectType } from 'tsd';
+import { createUnionParser } from './unionParser.js';
+import { type Parser, type ParserOutput } from './parser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+
+// Test: basic union of string parsers - output inferred as string
+{
+	const parser = createUnionParser([
+		createExactElementParser('a'),
+		createExactElementParser('b'),
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	expectAssignable<string>(null! as Output);
+	expectAssignable<Output>(null! as string);
+}
+
+// Test: union preserves literal types when parsers have explicit literal output types
+{
+	const parserA: Parser<'a', string> = async () => 'a' as const;
+	const parserB: Parser<'b', string> = async () => 'b' as const;
+
+	const parser = createUnionParser([parserA, parserB]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Output should be 'a' | 'b', not string
+	expectAssignable<'a' | 'b'>(null! as Output);
+	expectAssignable<Output>(null! as 'a' | 'b');
+}
+
+// Test: union of parsers with different output types
+{
+	const stringParser: Parser<string, string> = createFixedLengthSequenceParser(3);
+	const numberParser: Parser<number, string> = () => 42;
+
+	const parser = createUnionParser([
+		stringParser,
+		numberParser,
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Output should be string | number
+	expectAssignable<string | number>(null! as Output);
+	expectAssignable<Output>(null! as string | number);
+}
+
+// Test: nested unions
+{
+	const inner = createUnionParser([
+		createExactElementParser('a'),
+		createExactElementParser('b'),
+	]);
+
+	const parser = createUnionParser([
+		inner,
+		createExactElementParser('c'),
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	expectAssignable<string>(null! as Output);
+	expectAssignable<Output>(null! as string);
+}
+
+// Test: sequence type inferred from child parsers
+{
+	const parser = createUnionParser([
+		createExactSequenceParser('hello'),
+		createExactSequenceParser('world'),
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Parser should be for string sequences, output is string (widened from literals)
+	expectAssignable<string>(null! as Output);
+}
+
+// Test: single parser in union
+{
+	const parser = createUnionParser([
+		createExactSequenceParser('only'),
+	]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	// Output is string (widened from literal 'only')
+	expectAssignable<string>(null! as Output);
+}
+
+// Test: union of object-producing parsers
+{
+	const parser1: Parser<{ type: 'a'; value: number }, string> = async () => ({ type: 'a', value: 1 });
+	const parser2: Parser<{ type: 'b'; name: string }, string> = async () => ({ type: 'b', name: 'test' });
+
+	const parser = createUnionParser([parser1, parser2]);
+
+	type Output = ParserOutput<typeof parser>;
+
+	expectAssignable<{ type: 'a'; value: number } | { type: 'b'; name: string }>(null! as Output);
+}

package/src/unionParser.test.ts

@@ -31,26 +31,27 @@ test('union of union of union', async t => {
 });
 
 test('sync and async child parsers', async t => {
-	const parser = createArrayParser(createUnionParser<string, string>([
-		async parserContext => {
-			parserContext.invariant(
-				parserContext.position % 2 === 0,
-				'Expected an even position.',
-			);
+	const evenParser: Parser<string, string> = async parserContext => {
+		parserContext.invariant(
+			parserContext.position % 2 === 0,
+			'Expected an even position.',
+		);
 
-			return parserContext.read(0);
-		},
-		parserContext => {
-			parserContext.invariant(
-				parserContext.position % 2 === 1,
-				'Expected an odd position.',
-			);
+		return parserContext.read(0);
+	};
 
-			parserContext.skip(1);
+	const oddParser: Parser<string, string> = parserContext => {
+		parserContext.invariant(
+			parserContext.position % 2 === 1,
+			'Expected an odd position.',
+		);
 
-			return String.fromCodePoint('A'.codePointAt(0)! + parserContext.position - 1);
-		},
-	]));
+		parserContext.skip(1);
+
+		return String.fromCodePoint('A'.codePointAt(0)! + parserContext.position - 1);
+	};
+
+	const parser = createArrayParser(createUnionParser([evenParser, oddParser]));
 
 	const result = await runParser(parser, 'a?c?', stringParserInputCompanion, {
 		errorJoinMode: 'all',

package/src/unionParser.ts

@@ -1,9 +1,14 @@
 import { allSettledStream } from './allSettledStream.js';
-import { getParserName, setParserName, type Parser } from './parser.js';
+import { getParserName, setParserName, type Parser, type ParserOutput, type ParserSequence } from './parser.js';
 import { type ParserContext } from './parserContext.js';
 import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-import { type DeriveSequenceElement } from './sequence.js';
+
+// Union all output types from an array of parsers
+type UnionParserOutput<Parsers extends readonly unknown[]> = ParserOutput<Parsers[number]>;
+
+// Infer Sequence from parser array
+type InferSequenceFromParserArray<T extends readonly unknown[]> = ParserSequence<T[number]>;
 
 const bigintReplacer = (_key: string, value: unknown) => {
 	if (typeof value === 'bigint') {
@@ -13,24 +18,28 @@ const bigintReplacer = (_key: string, value: unknown) => {
 	return value;
 };
 
-export const createUnionParser = <
-	Output,
-	Sequence,
-	Element = DeriveSequenceElement<Sequence>,
+export function createUnionParser<
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const Parsers extends readonly Parser<any, any, any>[],
 >(
-	childParsers: Array<Parser<unknown, Sequence, Element>>,
-): Parser<Output, Sequence, Element> => {
+	childParsers: Parsers,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Parser<UnionParserOutput<Parsers>, InferSequenceFromParserArray<Parsers>> {
 	parserImplementationInvariant(childParsers.length > 0, 'Union parser must have at least one child parser.');
 
 	type TaskContext = {
-		childParser: Parser<unknown, Sequence, Element>;
-		childParserContext: ParserContext<Sequence, Element>;
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		childParser: Parser<any, any, any>;
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		childParserContext: ParserContext<any, any>;
 	};
 
-	const unionParser: Parser<Output, Sequence, Element> = async parserContext => {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const unionParser: Parser<any, any, any> = async parserContext => {
 		let runningChildParserContexts: TaskContext[] = [];
 
-		const createChildParserTask = (childParser: Parser<unknown, Sequence, Element>) => {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const createChildParserTask = (childParser: Parser<any, any, any>) => {
 			const childParserContext = parserContext.lookahead({
 				debugName: getParserName(childParser, 'anonymousUnionChild'),
 			});
@@ -42,7 +51,8 @@ export const createUnionParser = <
 
 			runningChildParserContexts.push(context);
 
-			const getChildParserPromise = (async () => childParser(childParserContext) as Promise<Output>);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const getChildParserPromise = (async () => childParser(childParserContext) as Promise<any>);
 
 			const promise = getChildParserPromise();
 
@@ -52,10 +62,12 @@ export const createUnionParser = <
 			};
 		};
 
-		const childParserResults = allSettledStream<Output, TaskContext>(childParsers.map(createChildParserTask));
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const childParserResults = allSettledStream<any, TaskContext>(childParsers.map(createChildParserTask));
 
 		const parserParsingFailedErrors: ParserParsingFailedError[] = [];
-		const successfulParserOutputs: Output[] = [];
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const successfulParserOutputs: any[] = [];
 		const successfulTaskContexts: TaskContext[] = [];
 		let didUnlookahead = false;
 
@@ -127,4 +139,4 @@ export const createUnionParser = <
 	].join('');
 
 	return setParserName(unionParser, name);
-};
+}