@futpib/parser 1.0.1 → 1.0.3

package/src/disjunctionParser.ts

@@ -1,16 +1,19 @@
 import { getParserName, setParserName, type Parser } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { promiseSettled } from './promiseSettled.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 export const createDisjunctionParser = <
 	Output,
 	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
 >(
-	childParsers: Array<Parser<any, Sequence, any>>,
-): Parser<Output, Sequence, unknown> => {
+	childParsers: Array<Parser<unknown, Sequence, Element>>,
+): Parser<Output, Sequence, Element> => {
 	parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
 
-	const disjunctionParser: Parser<Output, Sequence, unknown> = async parserContext => {
+	const disjunctionParser: Parser<Output, Sequence, Element> = async parserContext => {
 		const parserParsingFailedErrors: ParserParsingFailedError[] = [];
 
 		for (const childParser of childParsers) {
@@ -18,7 +21,7 @@ export const createDisjunctionParser = <
 				debugName: getParserName(childParser, 'anonymousDisjunctionChild'),
 			});
 
-			const [ childParserResult ] = await Promise.allSettled([ childParser(childParserContext) ]);
+			const childParserResult = await promiseSettled<Output>(childParser(childParserContext) as Promise<Output>);
 
 			if (childParserResult.status === 'fulfilled') {
 				const successfulParserOutput = childParserResult.value;
@@ -29,16 +32,18 @@ export const createDisjunctionParser = <
 				return successfulParserOutput;
 			}
 
+			childParserContext.dispose();
+
 			const error = childParserResult.reason;
 
-			if (error instanceof ParserParsingFailedError) {
+			if (isParserParsingFailedError(error)) {
 				parserParsingFailedErrors.push(error);
 			} else {
 				throw error;
 			}
 		}
 
-		parserContext.invariantJoin(
+		return parserContext.invariantJoin(
 			false,
 			parserParsingFailedErrors,
 			'No disjunction child parser succeeded.',

package/src/elementTerminatedArrayParser.test.ts

@@ -0,0 +1,99 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createTerminatedArrayParserNaive } from './terminatedArrayParser.js';
+import { type Parser, runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { HighResolutionTotalTimer } from './highResolutionTimer.js';
+import { createElementParser } from './elementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createElementTerminatedArrayParserUnsafe } from './elementTerminatedArrayParser.js';
+
+const naiveTotalTimer = new HighResolutionTotalTimer();
+const elementTotalTimer = new HighResolutionTotalTimer();
+
+testProp.serial(
+	'elementTerminatedArrayParserUnsafe',
+	[
+		fc
+			.string({
+				minLength: 1,
+			})
+			.map(string => ({
+				string,
+				terminator: string.slice(-1),
+			}))
+			.filter(({ string, terminator }) => string.split(terminator).length === 2),
+	],
+	async (t, { string, terminator }) => {
+		const terminatedArrayParserNaive = promiseCompose(
+			createTerminatedArrayParserNaive(
+				promiseCompose(
+					createTupleParser([
+						createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+						createElementParser<string>(),
+					]),
+					([ _, element ]) => element,
+				),
+				createExactSequenceParser(terminator),
+			),
+			([ characters ]) => characters,
+		);
+
+		const elementTerminatedArrayParserUnsafe = createElementTerminatedArrayParserUnsafe(
+			promiseCompose(
+				createTupleParser([
+					createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+					createElementParser<string>(),
+				]),
+				([ _, element ]) => element,
+			),
+			terminator,
+		);
+
+		const createTestWrapperParser = (innerParser: typeof elementTerminatedArrayParserUnsafe): Parser<{
+			string: string;
+			position: number;
+		}, string> => async parserContext => {
+			const characters = await innerParser(parserContext);
+
+			return {
+				string: characters.join(''),
+				nextPeek: await parserContext.peek(0),
+				position: parserContext.position,
+			};
+		};
+
+		const actualNaive = await naiveTotalTimer.measureAsync(async () => runParser(
+			createTestWrapperParser(terminatedArrayParserNaive),
+			string,
+			stringParserInputCompanion,
+		));
+
+		t.is(actualNaive.string.length, string.split(terminator)[0].length);
+
+		const actual = await elementTotalTimer.measureAsync(async () => runParser(
+			createTestWrapperParser(elementTerminatedArrayParserUnsafe),
+			string,
+			stringParserInputCompanion,
+		));
+
+		t.deepEqual(actual, actualNaive);
+	},
+	{
+		verbose: true,
+	},
+);
+
+test.serial(
+	'elementTerminatedArrayParserUnsafe performance',
+	t => {
+		t.true(
+			elementTotalTimer.time * 2n < naiveTotalTimer.time,
+			`Naive: ${naiveTotalTimer.time / 1_000_000n}ms, Unsafe: ${elementTotalTimer.time / 1_000_000n}ms`,
+		);
+	},
+);

package/src/elementTerminatedArrayParser.ts

@@ -0,0 +1,31 @@
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
+
+export const createElementTerminatedArrayParserUnsafe = <ElementOutput, Sequence, Element = DeriveSequenceElement<Sequence>>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	terminatorElement: Element,
+): Parser<ElementOutput[], Sequence> => {
+	const elementTerminatedArrayParserUnsafe: Parser<ElementOutput[], Sequence> = async parserContext => {
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const inputElement = await parserContext.peek(0);
+
+			if (inputElement === terminatorElement) {
+				parserContext.skip(1);
+
+				break;
+			}
+
+			const element = await elementParser(parserContext);
+
+			elements.push(element);
+		}
+
+		return elements;
+	};
+
+	setParserName(elementTerminatedArrayParserUnsafe, `${getParserName(elementParser, 'anonymousElement')}*?${JSON.stringify(terminatorElement)}`);
+
+	return elementTerminatedArrayParserUnsafe;
+};

package/src/elementTerminatedSequenceArrayParser.test.ts

@@ -0,0 +1,52 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { type Parser, runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createElementTerminatedSequenceArrayParser } from './elementTerminatedSequenceArrayParser.js';
+
+testProp.serial(
+	'elementTerminatedSequenceArrayParser',
+	[
+		fc
+			.string({
+				minLength: 1,
+			})
+			.map(string => ({
+				string,
+				terminator: string.slice(-1),
+			}))
+			.filter(({ string, terminator }) => string.split(terminator).length === 2),
+	],
+	async (t, { string, terminator }) => {
+		const elementTerminatedSequenceArrayParser = createElementTerminatedSequenceArrayParser<string>(terminator);
+
+		const createTestWrapperParser = (innerParser: typeof elementTerminatedSequenceArrayParser): Parser<{
+			strings: string[];
+			nextPeek: string | undefined;
+			position: number;
+		}, string> => async parserContext => {
+			const strings = await innerParser(parserContext);
+
+			return {
+				strings,
+				nextPeek: await parserContext.peek(0),
+				position: parserContext.position,
+			};
+		};
+
+		const actual = await runParser(
+			createTestWrapperParser(elementTerminatedSequenceArrayParser),
+			string,
+			stringParserInputCompanion,
+		);
+
+		t.deepEqual(actual, {
+			strings: [ string.split(terminator)[0] ],
+			nextPeek: undefined,
+			position: string.length,
+		});
+	},
+	{
+		verbose: true,
+	},
+);

package/src/elementTerminatedSequenceArrayParser.ts

@@ -0,0 +1,52 @@
+import { type Parser, setParserName } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
+
+export const createElementTerminatedSequenceArrayParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(
+	terminatorElement: Element,
+): Parser<Sequence[], Sequence, Element> => {
+	const elementTerminatedSequenceArrayParser: Parser<Sequence[], Sequence, Element> = async parserContext => {
+		const sequences: Sequence[] = [];
+
+		let start = 0;
+		let window = 1;
+
+		while (true) {
+			const sequence = await parserContext.peekSequence(start, start + window);
+
+			if (sequence === undefined) {
+				window = Math.floor(window / 2);
+
+				if (start === 0 && window === 0) {
+					break;
+				}
+
+				parserContext.invariant(window > 0, 'Unexpected end of input without terminator');
+
+				continue;
+			}
+
+			const terminatorIndex = parserContext.indexOf(sequence, terminatorElement);
+
+			if (terminatorIndex === -1) {
+				start += window;
+				window *= 2;
+
+				continue;
+			}
+
+			const sequence_ = await parserContext.readSequence(0, start + terminatorIndex);
+
+			parserContext.skip(1);
+
+			sequences.push(sequence_);
+
+			start = 0;
+		}
+
+		return sequences;
+	};
+
+	setParserName(elementTerminatedSequenceArrayParser, `(.*?${JSON.stringify(terminatorElement)})*`);
+
+	return elementTerminatedSequenceArrayParser;
+};

package/src/elementTerminatedSequenceParser.test.ts

@@ -0,0 +1,52 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { type Parser, runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createElementTerminatedSequenceParser } from './elementTerminatedSequenceParser.js';
+
+testProp.serial(
+	'elementTerminatedSequenceParser',
+	[
+		fc
+			.string({
+				minLength: 1,
+			})
+			.map(string => ({
+				string,
+				terminator: string.slice(-1),
+			}))
+			.filter(({ string, terminator }) => string.split(terminator).length === 2),
+	],
+	async (t, { string, terminator }) => {
+		const elementTerminatedSequenceParser = createElementTerminatedSequenceParser<string>(terminator);
+
+		const createTestWrapperParser = (innerParser: typeof elementTerminatedSequenceParser): Parser<{
+			string: string;
+			nextPeek: string | undefined;
+			position: number;
+		}, string> => async parserContext => {
+			const string = await innerParser(parserContext);
+
+			return {
+				string,
+				nextPeek: await parserContext.peek(0),
+				position: parserContext.position,
+			};
+		};
+
+		const actual = await runParser(
+			createTestWrapperParser(elementTerminatedSequenceParser),
+			string,
+			stringParserInputCompanion,
+		);
+
+		t.deepEqual(actual, {
+			string: string.split(terminator)[0],
+			nextPeek: undefined,
+			position: string.length,
+		});
+	},
+	{
+		verbose: true,
+	},
+);

package/src/elementTerminatedSequenceParser.ts

@@ -0,0 +1,43 @@
+import { type Parser, setParserName } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
+
+export const createElementTerminatedSequenceParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(
+	terminatorElement: Element,
+): Parser<Sequence, Sequence, Element> => {
+	const elementTerminatedSequenceParser: Parser<Sequence, Sequence, Element> = async parserContext => {
+		let start = 0;
+		let window = 1;
+
+		while (true) {
+			const sequence = await parserContext.peekSequence(start, start + window);
+
+			if (sequence === undefined) {
+				window = Math.floor(window / 2);
+
+				parserContext.invariant(!(start === 0 && window === 0), 'Unexpected end of input without terminated sequence');
+				parserContext.invariant(window > 0, 'Unexpected end of input without terminator');
+
+				continue;
+			}
+
+			const terminatorIndex = parserContext.indexOf(sequence, terminatorElement);
+
+			if (terminatorIndex === -1) {
+				start += window;
+				window *= 2;
+
+				continue;
+			}
+
+			const sequence_ = await parserContext.readSequence(0, start + terminatorIndex);
+
+			parserContext.skip(1);
+
+			return sequence_;
+		}
+	};
+
+	setParserName(elementTerminatedSequenceParser, `.*?${JSON.stringify(terminatorElement)}`);
+
+	return elementTerminatedSequenceParser;
+};

package/src/endOfInputParser.ts

@@ -8,4 +8,4 @@ export const createEndOfInputParser = <Sequence, Element = DeriveSequenceElement
 	);
 };
 
-export const endOfInputParser = createEndOfInputParser<any, any>();
+export const endOfInputParser = createEndOfInputParser<unknown, unknown>();

package/src/exactElementParser.ts

@@ -1,20 +1,26 @@
-import { type Parser } from './parser.js';
+import { setParserName, type Parser } from './parser.js';
 import { type DeriveSequenceElement } from './sequence.js';
 
 export const createExactElementParser = <
 	Sequence,
 	Element = DeriveSequenceElement<Sequence>,
->(element: Element): Parser<Element, Sequence, Element> => async parserContext => {
-	const actualElement = await parserContext.peek(0);
+>(element: Element): Parser<Element, Sequence, Element> => {
+	const exactElementParser: Parser<Element, Sequence, Element> = async parserContext => {
+		const actualElement = await parserContext.peek(0);
 
-	parserContext.invariant(
-		actualElement === element,
-		'Expected %s, got %s',
-		element,
-		actualElement,
-	);
+		parserContext.invariant(
+			actualElement === element,
+			'Expected %s, got %s',
+			element,
+			actualElement,
+		);
 
-	parserContext.skip(1);
+		parserContext.skip(1);
 
-	return element;
+		return element;
+	};
+
+	setParserName(exactElementParser, `createExactElementParser(${element})`);
+
+	return exactElementParser;
 };

package/src/exactElementSwitchParser.ts

@@ -0,0 +1,41 @@
+import invariant from "invariant";
+import { getParserName, Parser, setParserName } from "./parser.js";
+import { parserImplementationInvariant } from "./parserImplementationInvariant.js";
+import { DeriveSequenceElement } from "./sequence.js";
+
+export const createElementSwitchParser = <
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	childParsers: Map<Element, Parser<unknown, Sequence, Element>>,
+	defaultParser?: Parser<unknown, Sequence, Element>,
+): Parser<Output, Sequence, Element> => {
+	parserImplementationInvariant(childParsers.size > 0, 'Element switch parser must have at least one child parser.');
+
+	const elementSwitchParser: Parser<Output, Sequence, Element> = async parserContext => {
+		const currentElement = await parserContext.peek(0);
+
+		parserContext.invariant(currentElement !== undefined, 'Unexpected end of input.');
+		invariant(currentElement !== undefined, 'Unexpected end of input.');
+
+		const childParser = childParsers.get(currentElement) ?? defaultParser;
+
+		parserContext.invariant(childParser, `No child parser found for element: ${String(currentElement)}`);
+
+		const childParserOutput = await childParser!(parserContext) as Output;
+
+		return childParserOutput;
+	};
+
+	const name = [
+		'elementSwitch(',
+		...Array.from(childParsers.entries()).map(
+			([ element, childParser ]) => `${String(element)}=>${getParserName(childParser, 'anonymousElementSwitchChild')}`,
+		),
+		defaultParser ? `|default=>${getParserName(defaultParser, 'anonymousElementSwitchDefaultChild')}` : '',
+		')',
+	].join('');
+
+	return setParserName(elementSwitchParser, name);
+}

package/src/exactSequenceParser.ts

@@ -1,7 +1,7 @@
-import { inspect } from 'node:util';
 import { setParserName, type Parser } from './parser.js';
+import { inspect } from './inspect.js';
 
-export const createExactSequenceParser = <Sequence>(sequence: Sequence) => {
+export const createExactSequenceNaiveParser = <Sequence>(sequence: Sequence) => {
 	const exactSequenceParser: Parser<Sequence, Sequence, unknown> = async parserContext => {
 		const length = parserContext.length(sequence);
 
@@ -25,3 +25,24 @@ export const createExactSequenceParser = <Sequence>(sequence: Sequence) => {
 
 	return exactSequenceParser;
 };
+
+export const createExactSequenceParser = <Sequence>(expectedSequence: Sequence) => {
+	const exactSequenceParser: Parser<Sequence, Sequence, unknown> = async parserContext => {
+		const length = parserContext.length(expectedSequence);
+
+		const actualSequence = await parserContext.readSequence(0, length);
+
+		parserContext.invariant(
+			parserContext.equals(actualSequence, expectedSequence),
+			'Expected "%s", got "%s"',
+			() => inspect(expectedSequence),
+			() => inspect(actualSequence),
+		);
+
+		return expectedSequence;
+	};
+
+	setParserName(exactSequenceParser, inspect(expectedSequence));
+
+	return exactSequenceParser;
+};

package/src/fetchCid.test.ts

@@ -0,0 +1,20 @@
+import test from 'ava';
+import { fetchCid } from './fetchCid.js';
+
+const cid = 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda';
+
+test('fetchCid', async t => {
+	await Promise.all([
+		fetchCid(cid),
+		fetchCid(cid),
+		fetchCid(cid),
+	]);
+
+	await Promise.all([
+		fetchCid(cid),
+		fetchCid(cid),
+		fetchCid(cid),
+	]);
+
+	t.pass();
+});

package/src/fetchCid.ts

@@ -0,0 +1,121 @@
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import pMemoize from 'p-memoize';
+import envPaths from 'env-paths';
+
+const paths = envPaths('parser.futpib.github.io');
+
+function readableWebStreamOnFinish<T>(readableWebStream: ReadableStream<T>, onFinish: () => void): ReadableStream<T> {
+	const reader = readableWebStream.getReader();
+
+	const stream = new ReadableStream<T>({
+		async start(controller) {
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) {
+						break;
+					}
+
+					controller.enqueue(value);
+				}
+			} finally {
+				controller.close();
+				reader.releaseLock();
+				onFinish();
+			}
+		},
+		async cancel(reason) {
+			await reader.cancel(reason);
+			onFinish();
+		},
+	});
+
+	return stream;
+}
+
+class FsCache {
+	private get _basePath() {
+		return path.join(paths.cache, 'fetchCid');
+	}
+
+	private _getKeyPath(key: string) {
+		return path.join(this._basePath, key.replaceAll('/', '_'));
+	}
+
+	async get(key: string): Promise<[ ReadableStream<Uint8Array>, ReadableStream<Uint8Array> ] | undefined> {
+		try {
+			const file = await fsPromises.open(this._getKeyPath(key), 'r');
+
+			const stream = file.readableWebStream() as ReadableStream<Uint8Array>;
+
+			const streamWithClose = readableWebStreamOnFinish(stream, () => {
+				file.close();
+			});
+
+			return [ streamWithClose, undefined as unknown as ReadableStream<Uint8Array> ];
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+				return undefined;
+			}
+
+			throw error;
+		}
+	}
+
+	async has(key: string) {
+		const streams = await this.get(key);
+		try {
+			return streams !== undefined;
+		} finally {
+			for (const stream of streams ?? []) {
+				await stream?.cancel();
+			}
+		}
+	}
+
+	async set(key: string, [ _, value ]: [ ReadableStream<Uint8Array>, ReadableStream<Uint8Array> ]) {
+		await fsPromises.mkdir(this._basePath, {
+			recursive: true,
+		});
+		const file = await fsPromises.open(this._getKeyPath(key), 'w');
+		try {
+			for await (const chunk of value) {
+				await file.write(chunk);
+			}
+		} finally {
+			await file.close();
+		}
+	}
+
+	async delete(key: string) {
+		await fsPromises.unlink(this._getKeyPath(key));
+	}
+}
+
+async function reallyFetchCid(cid: string): Promise<[ ReadableStream<Uint8Array>, ReadableStream<Uint8Array> ]> {
+	const response = await fetch('https://ipfs.io/ipfs/' + cid);
+	return response.body!.tee();
+}
+
+const cachedReallyFetchCid = pMemoize(reallyFetchCid, {
+	cache: new FsCache(),
+});
+
+export async function fetchCid(cidOrPath: string): Promise<AsyncIterable<Uint8Array>> {
+	if (cidOrPath.includes('/')) {
+		const file = await fsPromises.open(cidOrPath, 'r');
+
+		const stream = file.readableWebStream() as ReadableStream<Uint8Array>;
+
+		const streamWithClose = readableWebStreamOnFinish(stream, () => {
+			file.close();
+		});
+
+		return streamWithClose;
+	}
+
+	const [ readable, unused ] = await cachedReallyFetchCid(cidOrPath);
+	await unused?.cancel();
+	return readable;
+}