@futpib/parser 1.0.1 → 1.0.3

package/src/parserError.ts

@@ -1,85 +1,168 @@
+import { type InputReaderState } from './inputReaderState.js';
+import { LazyMessage, NormalLazyMessageError, NoStackCaptureOverheadLazyMessageError } from './lazyMessageError.js';
 
-export class ParserError extends Error {
-	name = 'ParserError';
+export interface ParserError extends Error {
+	position: undefined | number;
+	inputReaderSate: undefined | InputReaderState<unknown>;
 }
 
-export class ParserImplementationError extends ParserError {
-	name = 'ParserImplementationError';
+export function isParserError(value: unknown): value is ParserError {
+	return (
+		typeof value === 'object'
+			&& value !== null
+			&& value instanceof Error
+			&& 'position' in value
+			&& (typeof value.position === 'number' || value.position === undefined)
+			&& 'inputReaderSate' in value
+			&& (value.inputReaderSate === undefined || typeof value.inputReaderSate === 'object')
+	);
 }
-export class ParserImplementationInvariantError extends ParserImplementationError {
-	name = 'ParserImplementationInvariantError';
+
+type ParserErrorInterface = ParserError;
+
+export interface ParserParsingFailedError extends ParserErrorInterface {
+	depth: number;
+	position: number;
 }
 
-export class ParserParsingFailedError extends ParserError {
-	name = 'ParserParsingFailedError';
-
-	constructor(
-		message: string,
-		public readonly depth: number,
-		public readonly position: number,
-	) {
-		super([
-			'(position: ',
-			position,
-			') ',
-			message,
-		].join(''));
-	}
+export function isParserParsingFailedError(value: unknown): value is ParserParsingFailedError {
+	return (
+		typeof value === 'object'
+			&& value !== null
+			&& value instanceof Error
+			&& 'depth' in value
+			&& typeof value.depth === 'number'
+			&& 'position' in value
+			&& typeof value.position === 'number'
+	);
 }
 
-export class ParserParsingJoinError extends ParserParsingFailedError {
-	name = 'ParserParsingJoinError';
+type ParserParsingFailedErrorInterface = ParserParsingFailedError;
 
-	public readonly childErrors: ParserParsingFailedError[] = [];
+export interface ParserParsingJoinError extends ParserParsingFailedErrorInterface {
+	childErrors: ParserParsingFailedErrorInterface[];
 }
 
-export class ParserParsingJoinNoneError extends ParserParsingJoinError {
-	name = 'ParserParsingJoinNoneError';
+export function isParserParsingJoinError(value: unknown): value is ParserParsingJoinError {
+	return (
+		typeof value === 'object'
+			&& value !== null
+			&& value instanceof Error
+			&& 'childErrors' in value
+			&& Array.isArray(value.childErrors)
+			&& value.childErrors.every((childError: unknown) => isParserParsingFailedError(childError))
+	);
 }
 
-export class ParserParsingJoinAllError extends ParserParsingJoinError {
-	name = 'ParserParsingJoinAllError';
+type ParserParsingJoinErrorInterface = ParserParsingJoinError;
+
+function createParserErrorModule(
+	BaseLazyMessageError: typeof NormalLazyMessageError | typeof NoStackCaptureOverheadLazyMessageError,
+) {
+	class ParserError extends BaseLazyMessageError implements ParserErrorInterface {
+		name = 'ParserError';
 
-	constructor(
-		message: string,
-		depth: number,
-		position: number,
-		public readonly childErrors: ParserParsingFailedError[],
-	) {
-		super(message, depth, position);
+		public position: undefined | number = undefined;
+		public inputReaderSate: undefined | InputReaderState<unknown> = undefined;
+	}
+
+	class ParserImplementationError extends ParserError {
+		name = 'ParserImplementationError';
+	}
+	class ParserImplementationInvariantError extends ParserImplementationError {
+		name = 'ParserImplementationInvariantError';
 	}
-}
 
-export class ParserParsingJoinDeepestError extends ParserParsingJoinError {
-	name = 'ParserParsingJoinDeepestError';
+	class ParserParsingFailedError extends ParserError implements ParserParsingFailedErrorInterface {
+		name = 'ParserParsingFailedError';
 
-	constructor(
-		message: string,
-		depth: number,
-		position: number,
-		public readonly childErrors: ParserParsingFailedError[],
-	) {
-		super(message, depth, position);
+		constructor(
+			message: LazyMessage,
+			public readonly depth: number,
+			public readonly position: number,
+		) {
+			super(message);
+		}
 	}
-}
 
-export class ParserParsingJoinFurthestError extends ParserParsingJoinError {
-	name = 'ParserParsingJoinFurthestError';
+	class ParserParsingJoinError extends ParserParsingFailedError implements ParserParsingJoinErrorInterface {
+		name = 'ParserParsingJoinError';
 
-	constructor(
-		message: string,
-		depth: number,
-		position: number,
-		public readonly childErrors: ParserParsingFailedError[],
-	) {
-		super(message, depth, position);
+		public readonly childErrors: ParserParsingFailedErrorInterface[] = [];
 	}
-}
 
-export class ParserParsingInvariantError extends ParserParsingFailedError {
-	name = 'ParserParsingInvariantError';
-}
+	class ParserParsingJoinNoneError extends ParserParsingJoinError {
+		name = 'ParserParsingJoinNoneError';
+	}
+
+	class ParserParsingJoinAllError extends ParserParsingJoinError {
+		name = 'ParserParsingJoinAllError';
+
+		constructor(
+			message: LazyMessage,
+			depth: number,
+			position: number,
+			public readonly childErrors: ParserParsingFailedErrorInterface[],
+		) {
+			super(message, depth, position);
+		}
+	}
 
-export class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
-	name = 'ParserUnexpectedEndOfInputError';
+	class ParserParsingJoinDeepestError extends ParserParsingJoinError {
+		name = 'ParserParsingJoinDeepestError';
+
+		constructor(
+			message: LazyMessage,
+			depth: number,
+			position: number,
+			public readonly childErrors: ParserParsingFailedErrorInterface[],
+		) {
+			super(message, depth, position);
+		}
+	}
+
+	class ParserParsingJoinFurthestError extends ParserParsingJoinError {
+		name = 'ParserParsingJoinFurthestError';
+
+		constructor(
+			message: LazyMessage,
+			depth: number,
+			position: number,
+			public readonly childErrors: ParserParsingFailedErrorInterface[],
+		) {
+			super(message, depth, position);
+		}
+	}
+
+	class ParserParsingInvariantError extends ParserParsingFailedError {
+		name = 'ParserParsingInvariantError';
+	}
+
+	class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
+		name = 'ParserUnexpectedEndOfInputError';
+	}
+
+	class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
+		name = 'ParserUnexpectedRemainingInputError';
+	}
+
+	return {
+		ParserError,
+		ParserImplementationError,
+		ParserImplementationInvariantError,
+		ParserParsingFailedError,
+		ParserParsingJoinError,
+		ParserParsingJoinNoneError,
+		ParserParsingJoinAllError,
+		ParserParsingJoinDeepestError,
+		ParserParsingJoinFurthestError,
+		ParserParsingInvariantError,
+		ParserUnexpectedEndOfInputError,
+		ParserUnexpectedRemainingInputError,
+	};
 }
+
+export type ParserErrorModule = ReturnType<typeof createParserErrorModule>;
+
+export const normalParserErrorModule = createParserErrorModule(NormalLazyMessageError);
+export const noStackCaptureOverheadParserErrorModule = createParserErrorModule(NoStackCaptureOverheadLazyMessageError);

package/src/parserImplementationInvariant.ts

@@ -1,6 +1,6 @@
-import { ParserImplementationInvariantError } from './parserError.js';
 import { type Falsy, customInvariant, type ValueOrAccessor } from './customInvariant.js';
+import { normalParserErrorModule } from './parserError.js';
 
-export function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy> {
-	return customInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
+export function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy> {
+	return customInvariant(normalParserErrorModule.ParserImplementationInvariantError, value, format, ...formatArguments);
 }

package/src/parserInputCompanion.ts

@@ -2,8 +2,13 @@
 export type ParserInputCompanion<Sequence, Element> = {
 	is(value: unknown): value is Sequence;
 	from(elements: Element[]): Sequence;
+	concat(sequences: Sequence[]): Sequence;
 	length(sequence: Sequence): number;
 	at(sequence: Sequence, index: number): Element | undefined;
+	subsequence(sequence: Sequence, start: number, end: number): Sequence;
+	indexOf(sequence: Sequence, element: Element, fromIndex?: number): number;
+	indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number;
+	equals(sequenceA: Sequence, sequenceB: Sequence): boolean;
 };
 
 export class StringParserInputCompanion implements ParserInputCompanion<string, string> {
@@ -15,6 +20,10 @@ export class StringParserInputCompanion implements ParserInputCompanion<string,
 		return elements.join('');
 	}
 
+	concat(sequences: string[]): string {
+		return sequences.join('');
+	}
+
 	length(sequence: string): number {
 		return sequence.length;
 	}
@@ -22,6 +31,22 @@ export class StringParserInputCompanion implements ParserInputCompanion<string,
 	at(sequence: string, index: number): string | undefined {
 		return sequence.at(index);
 	}
+
+	subsequence(sequence: string, start: number, end: number): string {
+		return sequence.slice(start, end);
+	}
+
+	indexOf(sequence: string, element: string, fromIndex?: number): number {
+		return sequence.indexOf(element, fromIndex);
+	}
+
+	indexOfSubsequence(sequence: string, subsequence: string, fromIndex?: number): number {
+		return sequence.indexOf(subsequence, fromIndex);
+	}
+
+	equals(sequenceA: string, sequenceB: string): boolean {
+		return sequenceA === sequenceB;
+	}
 }
 
 export const stringParserInputCompanion = new StringParserInputCompanion();
@@ -35,6 +60,10 @@ export class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint
 		return new Uint8Array(elements);
 	}
 
+	concat(sequences: Uint8Array[]): Uint8Array {
+		return new Uint8Array(Buffer.concat(sequences));
+	}
+
 	length(sequence: Uint8Array): number {
 		return sequence.length;
 	}
@@ -42,6 +71,32 @@ export class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint
 	at(sequence: Uint8Array, index: number): number | undefined {
 		return sequence.at(index);
 	}
+
+	subsequence(sequence: Uint8Array, start: number, end: number): Uint8Array {
+		return sequence.subarray(start, end);
+	}
+
+	indexOf(sequence: Uint8Array, element: number, fromIndex?: number): number {
+		return sequence.indexOf(element, fromIndex);
+	}
+
+	indexOfSubsequence(sequence: Uint8Array, subsequence: Uint8Array, fromIndex?: number): number {
+		return Buffer.from(sequence).indexOf(Buffer.from(subsequence), fromIndex);
+	}
+
+	equals(sequenceA: Uint8Array, sequenceB: Uint8Array): boolean {
+		if (sequenceA.length !== sequenceB.length) {
+			return false;
+		}
+
+		for (const [ index, element ] of sequenceA.entries()) {
+			if (element !== sequenceB[index]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
 }
 
 export const uint8ArrayParserInputCompanion = new Uint8ArrayParserInputCompanion();

package/src/promiseCompose.ts

@@ -1,7 +1,21 @@
 
 export function promiseCompose<A, B, C>(
-	f1: (a: A) => Promise<B>,
+	f1: (a: A) => B | Promise<B>,
 	f2: (b: B) => C | Promise<C>,
-): (a: A) => Promise<C> {
-	return async a => f1(a).then(f2);
+): (a: A) => C | Promise<C> {
+	async function promiseComposed(a: A) {
+		const bOrBPromise = f1(a);
+
+		if (bOrBPromise instanceof Promise) {
+			return bOrBPromise.then(f2);
+		}
+
+		return f2(bOrBPromise);
+	}
+
+	Object.defineProperty(promiseComposed, 'name', {
+		value: `promiseCompose(${f1.name}, ${f2.name})`,
+	});
+
+	return promiseComposed;
 }

package/src/promiseSettled.ts

@@ -0,0 +1,6 @@
+
+export async function promiseSettled<T>(promise: Promise<T>): Promise<PromiseSettledResult<T>> {
+	const [ promiseSettledResult ] = await Promise.allSettled([ promise ]);
+
+	return promiseSettledResult;
+}

package/src/separatedArrayParser.test.ts

@@ -0,0 +1,34 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedArrayParser } from './separatedArrayParser.js';
+import { type Parser, runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+
+test('does not loop forever with a child parser that does not consume anything', async t => {
+	const parser: Parser<undefined[], string> = createSeparatedArrayParser(async () => undefined, () => undefined);
+	const { output } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
+
+	t.deepEqual(output, []);
+});
+
+testProp(
+	'separatedArray',
+	[
+		fc.array(fc.constant('element')),
+	],
+	async (t, elements) => {
+		const separatedArrayParser = createSeparatedArrayParser(
+			createExactSequenceParser('element'),
+			createExactSequenceParser('separator'),
+		);
+
+		const actual = await runParser(separatedArrayParser, elements.join('separator'), stringParserInputCompanion);
+		const expected = elements;
+
+		t.deepEqual(actual, expected);
+	},
+	{
+		verbose: true,
+	},
+);

package/src/separatedArrayParser.ts

@@ -0,0 +1,55 @@
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { isParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+
+export const createSeparatedArrayParser = <ElementOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	separatorParser: Parser<unknown, Sequence>,
+): Parser<ElementOutput[], Sequence> => {
+	const separatorThenElementParser: Parser<ElementOutput, Sequence> = promiseCompose(
+		createTupleParser([
+			separatorParser,
+			elementParser,
+		]),
+		([ , element ]) => element,
+	);
+
+	const separatedArrayParser: Parser<ElementOutput[], Sequence> = async parserContext => {
+		let parser = elementParser;
+
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const elementParserContext = parserContext.lookahead();
+			const initialPosition = elementParserContext.position;
+
+			try {
+				const element = await parser(elementParserContext);
+
+				if (elementParserContext.position === initialPosition) {
+					break;
+				}
+
+				elements.push(element);
+				elementParserContext.unlookahead();
+			} catch (error) {
+				if (isParserParsingFailedError(error)) {
+					break;
+				}
+
+				throw error;
+			} finally {
+				elementParserContext.dispose();
+			}
+
+			parser = separatorThenElementParser;
+		}
+
+		return elements;
+	};
+
+	setParserName(separatedArrayParser, getParserName(elementParser, 'anonymousSeparatedArrayChild') + '*');
+
+	return separatedArrayParser;
+};

package/src/separatedNonEmptyArrayParser.test.ts

@@ -0,0 +1,117 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+import { type Parser, runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { stringFromAsyncIterable } from './stringFromAsyncIterable.js';
+
+test('empty input throws error', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	await t.throwsAsync(async () => runParser(parser, '', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});
+
+test('single element without separator matches', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	const result = await runParser(parser, 'element', stringParserInputCompanion);
+	t.deepEqual(result, [ 'element' ]);
+});
+
+test('two elements with separator matches', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	const result = await runParser(parser, 'element,element', stringParserInputCompanion);
+	t.deepEqual(result, [ 'element', 'element' ]);
+});
+
+test('multiple elements with separator matches', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('a'),
+		createExactSequenceParser(','),
+	);
+
+	const result = await runParser(parser, 'a,a,a,a', stringParserInputCompanion);
+	t.deepEqual(result, [ 'a', 'a', 'a', 'a' ]);
+});
+
+test('does not consume trailing separator', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	const { output, remainingInput } = await runParserWithRemainingInput(parser, 'element,element,', stringParserInputCompanion);
+	t.deepEqual(output, [ 'element', 'element' ]);
+	t.is(await stringFromAsyncIterable(remainingInput!), ',');
+});
+
+test('does not loop forever with a child parser that does not consume anything', async t => {
+	const parser: Parser<undefined[], string> = createSeparatedNonEmptyArrayParser(
+		async () => undefined,
+		() => undefined,
+	);
+
+	await t.throwsAsync(async () => runParser(parser, 'foo', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});
+
+test('partial match throws error', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	await t.throwsAsync(async () => runParser(parser, 'elem', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});
+
+testProp(
+	'separatedNonEmptyArray with at least one element',
+	[
+		fc.array(fc.constant('element'), { minLength: 1 }),
+	],
+	async (t, elements) => {
+		const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(
+			createExactSequenceParser('element'),
+			createExactSequenceParser('separator'),
+		);
+
+		const actual = await runParser(separatedNonEmptyArrayParser, elements.join('separator'), stringParserInputCompanion);
+		const expected = elements;
+
+		t.deepEqual(actual, expected);
+	},
+	{
+		verbose: true,
+	},
+);
+
+test('separatedNonEmptyArray throws on empty array', async t => {
+	const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser('separator'),
+	);
+
+	await t.throwsAsync(async () => runParser(separatedNonEmptyArrayParser, '', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});

package/src/separatedNonEmptyArrayParser.ts

@@ -0,0 +1,61 @@
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+
+export const createSeparatedNonEmptyArrayParser = <ElementOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	separatorParser: Parser<unknown, Sequence>,
+): Parser<ElementOutput[], Sequence> => {
+	const separatorThenElementParser: Parser<ElementOutput, Sequence> = promiseCompose(
+		createTupleParser([
+			separatorParser,
+			elementParser,
+		]),
+		([ , element ]) => element,
+	);
+
+	const separatedNonEmptyArrayParser: Parser<ElementOutput[], Sequence> = async parserContext => {
+		let parser = elementParser;
+
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const elementParserContext = parserContext.lookahead();
+			const initialPosition = elementParserContext.position;
+
+			try {
+				const element = await parser(elementParserContext);
+
+				if (elementParserContext.position === initialPosition) {
+					break;
+				}
+
+				elements.push(element);
+				elementParserContext.unlookahead();
+			} catch (error) {
+				if (isParserParsingFailedError(error)) {
+					break;
+				}
+
+				throw error;
+			} finally {
+				elementParserContext.dispose();
+			}
+
+			parser = separatorThenElementParser;
+		}
+
+		parserContext.invariant(
+			elements.length > 0,
+			'Expected elementParser (%s) to match at least once',
+			getParserName(elementParser, 'anonymousSeparatedNonEmptyArrayChild'),
+		);
+
+		return elements;
+	};
+
+	setParserName(separatedNonEmptyArrayParser, getParserName(elementParser, 'anonymousSeparatedNonEmptyArrayChild') + '+');
+
+	return separatedNonEmptyArrayParser;
+};