@futpib/parser 1.0.3 → 1.0.6

package/src/zipParser.ts

@@ -4,6 +4,7 @@ import { pipeline } from 'node:stream/promises';
 import invariant from 'invariant';
 import { createArrayParser } from './arrayParser.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createObjectParser } from './objectParser.js';
 import { type Parser, setParserName } from './parser.js';
 import { createTupleParser } from './tupleParser.js';
 import { promiseCompose } from './promiseCompose.js';
@@ -146,28 +147,15 @@ type ZipDataDescriptor = {
 const zipDataDescriptorSignature: Uint8Array = Buffer.from('504b0708', 'hex');
 const zipDataDescriptorSignatureParser = createExactSequenceParser<Uint8Array>(zipDataDescriptorSignature);
 
-const zipDataDescriptorParser: Parser<ZipDataDescriptor, Uint8Array> = promiseCompose(
-	createTupleParser([
-		createNegativeLookaheadParser(zipLocalFileHeaderSignatureParser),
-		// FIXME: optional in spec
-		// createOptionalParser(zipDataDescriptorSignatureParser),
-		zipDataDescriptorSignatureParser,
-		uint32LEParser,
-		uint32LEParser,
-		uint32LEParser,
-	]),
-	([
-		_notZipLocalFileHeaderSignature,
-		_zipDataDescriptorSignature,
-		crc32,
-		compressedSize,
-		uncompressedSize,
-	]) => ({
-		crc32,
-		compressedSize,
-		uncompressedSize,
-	}),
-);
+const zipDataDescriptorParser: Parser<ZipDataDescriptor, Uint8Array> = createObjectParser({
+	_notZipLocalFileHeaderSignature: createNegativeLookaheadParser(zipLocalFileHeaderSignatureParser),
+	// FIXME: optional in spec
+	// _zipDataDescriptorSignature: createOptionalParser(zipDataDescriptorSignatureParser),
+	_zipDataDescriptorSignature: zipDataDescriptorSignatureParser,
+	crc32: uint32LEParser,
+	compressedSize: uint32LEParser,
+	uncompressedSize: uint32LEParser,
+});
 
 setParserName(zipDataDescriptorParser, 'zipDataDescriptorParser');
 
@@ -411,40 +399,16 @@ export type ZipEndOfCentralDirectoryRecord = {
 	zipFileComment: string;
 };
 
-const zipEndOfCentralDirectoryRecordParser_ = createTupleParser([
-	createExactSequenceParser<Uint8Array>(Buffer.from('504b0506', 'hex')),
-	uint16LEParser,
-	uint16LEParser,
-	uint16LEParser,
-	uint16LEParser,
-	uint32LEParser,
-	uint32LEParser,
-	zipFileCommentParser,
-]);
-
-setParserName(zipEndOfCentralDirectoryRecordParser_, 'zipEndOfCentralDirectoryRecordParser_');
-
-export const zipEndOfCentralDirectoryRecordParser: Parser<ZipEndOfCentralDirectoryRecord, Uint8Array> = promiseCompose(
-	zipEndOfCentralDirectoryRecordParser_,
-	([
-		_endOfCentralDirectoryRecordSignature,
-		numberOfThisDisk,
-		numberOfTheDiskWithTheStartOfTheCentralDirectory,
-		totalNumberOfEntriesInTheCentralDirectoryOnThisDisk,
-		totalNumberOfEntriesInTheCentralDirectory,
-		sizeOfTheCentralDirectory,
-		offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber,
-		zipFileComment,
-	]) => ({
-		numberOfThisDisk,
-		numberOfTheDiskWithTheStartOfTheCentralDirectory,
-		totalNumberOfEntriesInTheCentralDirectoryOnThisDisk,
-		totalNumberOfEntriesInTheCentralDirectory,
-		sizeOfTheCentralDirectory,
-		offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber,
-		zipFileComment,
-	}),
-);
+export const zipEndOfCentralDirectoryRecordParser: Parser<ZipEndOfCentralDirectoryRecord, Uint8Array> = createObjectParser({
+	_endOfCentralDirectoryRecordSignature: createExactSequenceParser<Uint8Array>(Buffer.from('504b0506', 'hex')),
+	numberOfThisDisk: uint16LEParser,
+	numberOfTheDiskWithTheStartOfTheCentralDirectory: uint16LEParser,
+	totalNumberOfEntriesInTheCentralDirectoryOnThisDisk: uint16LEParser,
+	totalNumberOfEntriesInTheCentralDirectory: uint16LEParser,
+	sizeOfTheCentralDirectory: uint32LEParser,
+	offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber: uint32LEParser,
+	zipFileComment: zipFileCommentParser,
+});
 
 setParserName(zipEndOfCentralDirectoryRecordParser, 'zipEndOfCentralDirectoryRecordParser');
 

package/src/zipUnparser.test.ts

@@ -40,7 +40,7 @@ async function _7zList(zipFilePath: string) {
 	}
 
 	return {
-		isEmptyZipfile: false, // TODO
+		isEmptyZipfile: /\b0 files\b/.test(stdout),
 	};
 }
 

package/src/zipUnparser.ts

@@ -134,6 +134,14 @@ export const createZipUnparser = ({
 		return [ [ zipEntry, promise.then(([ , compressedContent ]) => compressedContent) ] ];
 	}));
 
+	const crc32ByZipFileEntry = new Map<ZipFileEntry, number>(zip.entries.flatMap(zipEntry => {
+		if (zipEntry.type !== 'file') {
+			return [];
+		}
+
+		return [ [ zipEntry, zlib.crc32(zipEntry.content) ] ];
+	}));
+
 	const filePathByZipEntry = new Map<ZipEntry, string>(zip.entries.map(zipEntry => [ zipEntry, zipEntry.type === 'file' ? zipEntry.path : zipEntry.path + '/' ]));
 
 	const localHeaderPositionByZipEntry = new Map<ZipEntry, number>();
@@ -156,14 +164,21 @@ export const createZipUnparser = ({
 		};
 
 		let shouldWriteDataDescriptor = false;
+		let actualCrc32 = 0;
+		let actualCompressedSize = 0;
+		let actualUncompressedSize = 0;
 
 		if (zipEntry.type === 'file') {
 			const compressedContent = await compressedContentByZipFileEntry.get(zipEntry)!;
 
 			zipLocalFileHeader.compressionMethod = zipEntry.compression;
-			zipLocalFileHeader.crc32 = 0; // TODO
-			zipLocalFileHeader.compressedSize = compressedContent.length;
-			zipLocalFileHeader.uncompressedSize = zipEntry.content.length;
+			actualCrc32 = crc32ByZipFileEntry.get(zipEntry)!;
+			actualCompressedSize = compressedContent.length;
+			actualUncompressedSize = zipEntry.content.length;
+
+			zipLocalFileHeader.crc32 = actualCrc32;
+			zipLocalFileHeader.compressedSize = actualCompressedSize;
+			zipLocalFileHeader.uncompressedSize = actualUncompressedSize;
 
 			if (dataDescriptor) {
 				shouldWriteDataDescriptor = true;
@@ -184,9 +199,9 @@ export const createZipUnparser = ({
 
 			if (shouldWriteDataDescriptor) {
 				yield * zipDataDescriptorUnparser({
-					crc32: zipLocalFileHeader.crc32,
-					compressedSize: zipLocalFileHeader.compressedSize,
-					uncompressedSize: zipLocalFileHeader.uncompressedSize,
+					crc32: actualCrc32,
+					compressedSize: actualCompressedSize,
+					uncompressedSize: actualUncompressedSize,
 				}, unparserContext);
 			}
 		}
@@ -215,7 +230,7 @@ export const createZipUnparser = ({
 		if (zipEntry.type === 'file') {
 			const compressedContent = await compressedContentByZipFileEntry.get(zipEntry)!;
 
-			yield * uint32LEUnparser(0, unparserContext); // Crc32 // TODO
+			yield * uint32LEUnparser(crc32ByZipFileEntry.get(zipEntry)!, unparserContext);
 			yield * uint32LEUnparser(compressedContent.length, unparserContext);
 			yield * uint32LEUnparser(zipEntry.content.length, unparserContext);
 		} else {

package/tsconfig.json

@@ -12,7 +12,7 @@
 
     /* Language and Environment */
     "target": "es2022",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    "lib": ["ES2022", "ESNext.Disposable"],              /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
     // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
     // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
@@ -31,7 +31,7 @@
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
     // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    "typeRoots": ["./node_modules-@types", "./node_modules/@types"],   /* Specify multiple folders that act like './node_modules/@types'. */
     // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
     // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
     // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */

package/build/exactElementSwitchParser.d.ts

@@ -1,3 +0,0 @@
-import { Parser } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
-export declare const createElementSwitchParser: <Output, Sequence, Element = DeriveSequenceElement<Sequence>>(childParsers: Map<Element, Parser<unknown, Sequence, Element>>, defaultParser?: Parser<unknown, Sequence, Element>) => Parser<Output, Sequence, Element>;

package/src/exactElementSwitchParser.ts

@@ -1,41 +0,0 @@
-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);
-}