@futpib/parser 1.0.1 → 1.0.3

package/build/zipUnparser.js

@@ -28,12 +28,7 @@ const dosDateTimeUnparser = async function* (date, unparserContext) {
         | (date.getUTCFullYear() - 1980) << 9), unparserContext);
 };
 const zipCompressionMethodUnparser = async function* (compressionMethod, unparserContext) {
-    if (compressionMethod === 'store') {
-        yield* uint16LEUnparser(0, unparserContext);
-    }
-    else {
-        yield* uint16LEUnparser(8, unparserContext);
-    }
+    yield* (compressionMethod === 'store' ? uint16LEUnparser(0, unparserContext) : uint16LEUnparser(8, unparserContext));
 };
 export const zipEndOfCentralDirectoryRecordUnparser = async function* (zipEndOfCentralDirectoryRecord, unparserContext) {
     yield Buffer.from('504b0506', 'hex');
@@ -45,7 +40,28 @@ export const zipEndOfCentralDirectoryRecordUnparser = async function* (zipEndOfC
     yield* uint32LEUnparser(zipEndOfCentralDirectoryRecord.offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber, unparserContext);
     yield* uint16LEPrefixedStringUnparser(zipEndOfCentralDirectoryRecord.zipFileComment, unparserContext);
 };
-export const zipUnparser = async function* (zip, unparserContext) {
+const zipDataDescriptorUnparser = async function* ({ crc32, compressedSize, uncompressedSize, }, unparserContext) {
+    yield Buffer.from('504b0708', 'hex');
+    yield* uint32LEUnparser(crc32, unparserContext);
+    yield* uint32LEUnparser(compressedSize, unparserContext);
+    yield* uint32LEUnparser(uncompressedSize, unparserContext);
+};
+const zipLocalFileHeaderUnparser = async function* ({ versionNeededToExtract, generalPurposeBitFlag, compressionMethod, lastModifiedFile, crc32, compressedSize, uncompressedSize, filePath, extraField, }, unparserContext) {
+    yield Buffer.from('504b0304', 'hex');
+    yield* uint16LEUnparser(versionNeededToExtract, unparserContext);
+    yield* uint16LEUnparser(generalPurposeBitFlag, unparserContext);
+    yield* zipCompressionMethodUnparser(compressionMethod, unparserContext);
+    yield* dosDateTimeUnparser(lastModifiedFile, unparserContext);
+    yield* uint32LEUnparser(crc32, unparserContext);
+    yield* uint32LEUnparser(compressedSize, unparserContext);
+    yield* uint32LEUnparser(uncompressedSize, unparserContext);
+    const filePathBuffer = Buffer.from(filePath, 'utf8');
+    yield* uint16LEUnparser(filePathBuffer.length, unparserContext);
+    yield* uint16LEUnparser(extraField.length, unparserContext);
+    yield filePathBuffer;
+    yield extraField;
+};
+export const createZipUnparser = ({ dataDescriptor = false, } = {}) => async function* (zip, unparserContext) {
     const compressedContentByZipFileEntry = new Map(zip.entries.flatMap(zipEntry => {
         if (zipEntry.type !== 'file') {
             return [];
@@ -66,62 +82,64 @@ export const zipUnparser = async function* (zip, unparserContext) {
     const localHeaderPositionByZipEntry = new Map();
     for (const zipEntry of zip.entries) {
         localHeaderPositionByZipEntry.set(zipEntry, unparserContext.position);
-        yield Buffer.from('504b0304', 'hex');
-        yield* uint16LEUnparser(10, unparserContext); // version needed to extract
-        yield* uint16LEUnparser(0, unparserContext); // general purpose bit flag
-        if (zipEntry.type === 'file') {
-            yield* zipCompressionMethodUnparser(zipEntry.compression, unparserContext);
-        }
-        else {
-            yield* uint16LEUnparser(0, unparserContext);
-        }
-        yield* dosDateTimeUnparser(zipEntry.date, unparserContext);
+        const filePath = filePathByZipEntry.get(zipEntry);
+        const zipLocalFileHeader = {
+            versionNeededToExtract: 20,
+            generalPurposeBitFlag: 0,
+            compressionMethod: 'store',
+            lastModifiedFile: zipEntry.date,
+            crc32: 0,
+            compressedSize: 0,
+            uncompressedSize: 0,
+            filePath,
+            extraField: Buffer.alloc(0),
+        };
+        let shouldWriteDataDescriptor = false;
         if (zipEntry.type === 'file') {
             const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
-            yield* uint32LEUnparser(0, unparserContext); // crc32 // TODO
-            yield* uint32LEUnparser(compressedContent.length, unparserContext);
-            yield* uint32LEUnparser(zipEntry.content.length, unparserContext);
-        }
-        else {
-            yield* uint32LEUnparser(0, unparserContext);
-            yield* uint32LEUnparser(0, unparserContext);
-            yield* uint32LEUnparser(0, unparserContext);
+            zipLocalFileHeader.compressionMethod = zipEntry.compression;
+            zipLocalFileHeader.crc32 = 0; // TODO
+            zipLocalFileHeader.compressedSize = compressedContent.length;
+            zipLocalFileHeader.uncompressedSize = zipEntry.content.length;
+            if (dataDescriptor) {
+                shouldWriteDataDescriptor = true;
+                zipLocalFileHeader.generalPurposeBitFlag |= 0b0000_0000_0000_1000;
+                zipLocalFileHeader.crc32 = 0;
+                zipLocalFileHeader.compressedSize = 0;
+                zipLocalFileHeader.uncompressedSize = 0;
+            }
         }
-        const filePath = filePathByZipEntry.get(zipEntry);
-        const filePathBuffer = Buffer.from(filePath, 'utf8');
-        const extraFieldBuffer = Buffer.alloc(0);
-        yield* uint16LEUnparser(filePathBuffer.length, unparserContext);
-        yield* uint16LEUnparser(extraFieldBuffer.length, unparserContext);
-        yield filePathBuffer;
-        yield extraFieldBuffer;
+        yield* zipLocalFileHeaderUnparser(zipLocalFileHeader, unparserContext);
         if (zipEntry.type === 'file') {
             const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
             yield compressedContent;
+            if (shouldWriteDataDescriptor) {
+                yield* zipDataDescriptorUnparser({
+                    crc32: zipLocalFileHeader.crc32,
+                    compressedSize: zipLocalFileHeader.compressedSize,
+                    uncompressedSize: zipLocalFileHeader.uncompressedSize,
+                }, unparserContext);
+            }
         }
     }
     const startOfCentralDirectoryPosition = unparserContext.position;
     for (const zipEntry of zip.entries) {
         yield Buffer.from('504b0102', 'hex');
         if (zipEntry.hostSystem === 'unix') {
-            yield 0; // zip specification version
-            yield 3; // host system
+            yield 0; // Zip specification version
+            yield 3; // Host system
         }
         else {
             yield 0;
             yield 0;
         }
-        yield* uint16LEUnparser(0, unparserContext); // version needed to extract
-        yield* uint16LEUnparser(0, unparserContext); // general purpose bit flag
-        if (zipEntry.type === 'file') {
-            yield* zipCompressionMethodUnparser(zipEntry.compression, unparserContext);
-        }
-        else {
-            yield* uint16LEUnparser(0, unparserContext);
-        }
+        yield* uint16LEUnparser(0, unparserContext); // Version needed to extract
+        yield* uint16LEUnparser(0, unparserContext); // General purpose bit flag
+        yield* (zipEntry.type === 'file' ? zipCompressionMethodUnparser(zipEntry.compression, unparserContext) : uint16LEUnparser(0, unparserContext));
         yield* dosDateTimeUnparser(zipEntry.date, unparserContext);
         if (zipEntry.type === 'file') {
             const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
-            yield* uint32LEUnparser(0, unparserContext); // crc32 // TODO
+            yield* uint32LEUnparser(0, unparserContext); // Crc32 // TODO
             yield* uint32LEUnparser(compressedContent.length, unparserContext);
             yield* uint32LEUnparser(zipEntry.content.length, unparserContext);
         }
@@ -137,8 +155,8 @@ export const zipUnparser = async function* (zip, unparserContext) {
         yield* uint16LEUnparser(extraFieldBuffer.length, unparserContext);
         const fileCommentBuffer = Buffer.from(zipEntry.comment, 'utf8');
         yield* uint16LEUnparser(fileCommentBuffer.length, unparserContext);
-        yield* uint16LEUnparser(0, unparserContext); // disk number start
-        yield* uint16LEUnparser(0, unparserContext); // internal file attributes
+        yield* uint16LEUnparser(0, unparserContext); // Disk number start
+        yield* uint16LEUnparser(0, unparserContext); // Internal file attributes
         if (zipEntry.hostSystem === 'unix') {
             yield* uint32LEUnparser((0
                 | (zipEntry.type === 'directory'
@@ -169,3 +187,4 @@ export const zipUnparser = async function* (zip, unparserContext) {
         zipFileComment: zip.comment,
     }, unparserContext);
 };
+export const zipUnparser = createZipUnparser();

package/build/zipUnparser.test.js

@@ -1,21 +1,15 @@
-import { testProp } from '@fast-check/ava';
+import fsPromises from 'node:fs/promises';
+import { fc, testProp } from '@fast-check/ava';
 import { temporaryFile } from 'tempy';
 import { execa } from 'execa';
-import fsPromises from 'node:fs/promises';
 import { runUnparser } from './unparser.js';
-import { zipUnparser } from './zipUnparser.js';
+import { createZipUnparser } from './zipUnparser.js';
 import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
 import { runParser } from './parser.js';
 import { zipParser } from './zipParser.js';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { arbitraryZip } from './arbitraryZip.js';
-async function hasExecutable(executable) {
-    const hasExecutable = execa(executable).then(() => true, () => false);
-    if (!hasExecutable) {
-        console.warn(`Executable %o not found`, executable);
-    }
-    return hasExecutable;
-}
+import { hasExecutable } from './hasExecutable.js';
 const hasZipinfoPromise = hasExecutable('zipinfo');
 const has7zPromise = hasExecutable('7z');
 async function zipinfo(zipFilePath) {
@@ -45,16 +39,22 @@ async function _7zList(zipFilePath) {
 }
 testProp('zip', [
     arbitraryZip,
-], async (t, zip) => {
+    fc.record({
+        dataDescriptor: fc.boolean(),
+    }),
+], async (t, zip, options) => {
+    const zipUnparser = createZipUnparser(options);
+    {
+        const zipStream = runUnparser(zipUnparser, zip, uint8ArrayUnparserOutputCompanion);
+        await fsPromises.writeFile('/tmp/zip.zip', zipStream);
+    }
     const actualStream = runUnparser(zipUnparser, zip, uint8ArrayUnparserOutputCompanion);
     const actual = await runParser(zipParser, actualStream, uint8ArrayParserInputCompanion);
-    const isDeepEqual = t.deepEqual(actual, zip);
-    if (!isDeepEqual) {
-        return;
-    }
+    t.deepEqual(actual, zip);
     const hasZipinfo = await hasZipinfoPromise;
     const has7z = await has7zPromise;
     if (!hasZipinfo && !has7z) {
+        t.pass('no zipinfo or 7z, skipping zipfile check');
         return;
     }
     const temporaryFilePath = temporaryFile({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futpib/parser",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "build/index.js",
   "license": "GPL-3.0-only",
   "type": "module",
@@ -18,37 +18,46 @@
       },
       "compile": false
     },
-    "verbose": true
+    "verbose": true,
+    "timeout": "60s"
   },
   "devDependencies": {
-    "@ava/typescript": "^5.0.0",
-    "@fast-check/ava": "^2.0.1",
+    "@ava/typescript": "^6.0.0",
+    "@fast-check/ava": "^2.0.2",
     "@types/invariant": "^2.2.37",
-    "@types/node": "^22.10.1",
-    "ava": "^6.2.0",
-    "bson": "^6.10.0",
-    "c8": "^10.1.2",
+    "@types/node": "^24.4.0",
+    "ava": "^6.4.1",
+    "bson": "^6.10.4",
+    "c8": "^10.1.3",
     "coveralls": "^3.1.1",
-    "eslint-config-xo-typescript-overrides": "^1.6.1",
-    "execa": "^9.5.2",
-    "fast-check": "^3.23.1",
+    "env-paths": "^3.0.0",
+    "eslint-config-xo-typescript-overrides": "^2.0.3",
+    "execa": "^9.6.0",
+    "fast-check": "^4.3.0",
     "invariant": "^2.2.4",
     "jszip": "^3.10.1",
+    "leb128": "^0.0.5",
+    "mutf-8": "^1.2.2",
+    "p-memoize": "^8.0.0",
     "tempy": "^3.1.0",
-    "type-fest": "^4.29.0",
-    "typescript": "^5.7.2",
-    "xo": "^0.59.3"
+    "type-fest": "^5.0.0",
+    "typescript": "^5.9.2",
+    "xo": "^1.2.2"
   },
-  "xo": {
-    "extends": [
-      "eslint-config-xo-typescript-overrides"
-    ],
-    "rules": {
-      "ava/no-ignored-test-files": "off"
-    }
-  },
-  "packageManager": "yarn@4.5.3",
+  "packageManager": "yarn@4.9.4",
   "dependencies": {
-    "p-mutex": "^0.1.0"
+    "fp-ts": "^2.16.11",
+    "mem": "^10.0.0",
+    "monocle-ts": "^2.3.13",
+    "newtype-ts": "^0.3.5",
+    "p-mutex": "^1.0.0"
+  },
+  "peerDependencies": {
+    "mutf-8": "^1.1.4"
+  },
+  "peerDependenciesMeta": {
+    "mutf-8": {
+      "optional": true
+    }
   }
 }

package/src/allSettledStream.test.ts

@@ -57,3 +57,43 @@ test('allSettledStream', async t => {
 	t.snapshot(results);
 	t.is(results.length, 8);
 });
+
+test('allSettledStream reader cancel', async t => {
+	const stream = allSettledStream<number, number>([
+		10,
+		20,
+		0,
+		40,
+		30,
+	].map(delay => ({
+		promise: new Promise<number>(resolve => {
+			setTimeout(() => {
+				resolve(delay);
+			}, delay);
+		}),
+		context: delay,
+	})));
+
+	const results: any[] = [];
+
+	for await (const value of stream) {
+		results.push(value);
+
+		if (value.context === 30) {
+			break;
+		}
+	}
+
+	await new Promise<void>(resolve => {
+		setTimeout(resolve, 50);
+	});
+
+	stream.cancel();
+
+	for await (const value of stream) {
+		t.fail();
+		results.push(value);
+	}
+
+	t.deepEqual(results.map(({ context }) => context), [ 0, 10, 20, 30 ]);
+});

package/src/allSettledStream.ts

@@ -1,3 +1,5 @@
+import { promiseSettled } from './promiseSettled.js';
+
 type AllSettledStreamFulfilledResult<T, Context> = {
 	status: 'fulfilled';
 	value: T;
@@ -18,27 +20,57 @@ type AllSettledStreamTask<T, Context> = {
 };
 
 export function allSettledStream<T, Context>(tasks: Array<AllSettledStreamTask<T, Context>>): ReadableStream<AllSettedStreamResult<T, Context>> {
+	let cancelled = false;
+
 	return new ReadableStream({
-		async start(controller) {
-			let settledCount = 0;
-			for (const { promise, context } of tasks) {
-				(async () => {
-					const [ promiseSettledResult ] = await Promise.allSettled([ promise ]);
+		start(controller) {
+			const startStack = (
+				(new Error('allSettledStream ReadableStream start stack holder').stack ?? '')
+					.split('\n')
+					.slice(1)
+					.join('\n')
+			);
+
+			const allSettledStreamTaskAwaiter = async ({
+				promise,
+				context,
+			}: AllSettledStreamTask<T, Context>) => {
+				const promiseSettledResult = await promiseSettled(promise);
+
+				if (
+					promiseSettledResult.status === 'rejected'
+					&& promiseSettledResult.reason instanceof Error
+					&& promiseSettledResult.reason.stack
+				) {
+					promiseSettledResult.reason.stack += `\n${startStack}`;
+				}
 
-					settledCount++;
+				settledCount++;
 
-					const allSettedStreamResult: AllSettedStreamResult<T, Context> = {
-						...promiseSettledResult,
-						context,
-					};
+				if (cancelled) {
+					return;
+				}
 
-					controller.enqueue(allSettedStreamResult);
+				const allSettedStreamResult: AllSettedStreamResult<T, Context> = {
+					...promiseSettledResult,
+					context,
+				};
 
-					if (settledCount === tasks.length) {
-						controller.close();
-					}
-				})();
+				controller.enqueue(allSettedStreamResult);
+
+				if (settledCount === tasks.length) {
+					controller.close();
+				}
+			};
+
+			let settledCount = 0;
+			for (const task of tasks) {
+				allSettledStreamTaskAwaiter(task);
 			}
 		},
+
+		cancel() {
+			cancelled = true;
+		},
 	});
 }

package/src/androidPackage.ts

@@ -0,0 +1,48 @@
+import { type Zip } from './zip.js';
+
+export type AndroidPackageSigningBlockPair = {
+	id: number;
+	value: Uint8Array;
+};
+
+export type AndroidPackageSignatureV2Digest = {
+	signatureAlgorithmId: number;
+	digest: Uint8Array;
+};
+
+export type AndroidPackageSignatureV2AdditionalAttribute = {
+	id: number;
+	value: Uint8Array;
+};
+
+export type AndroidPackageSignatureV2SignedData = {
+	digests: AndroidPackageSignatureV2Digest[];
+	certificates: Uint8Array[];
+	additionalAttributes: AndroidPackageSignatureV2AdditionalAttribute[];
+	zeroPaddingLength?: number;
+};
+
+export type AndroidPackageSignatureV2Signature = {
+	signatureAlgorithmId: number;
+	signature: Uint8Array;
+};
+
+export type AndroidPackageSignatureV2Signer = {
+	signedData: AndroidPackageSignatureV2SignedData;
+	signatures: AndroidPackageSignatureV2Signature[];
+	publicKey: Uint8Array;
+};
+
+export type AndroidPackageSignatureV2 = {
+	signers: AndroidPackageSignatureV2Signer[];
+};
+
+export type AndroidPackageSigningBlock = {
+	pairs: AndroidPackageSigningBlockPair[];
+	signatureV2?: AndroidPackageSignatureV2;
+	zeroPaddingLength?: number;
+};
+
+export type AndroidPackage = Zip & {
+	signingBlock?: AndroidPackageSigningBlock;
+};

package/src/androidPackageParser.test.ts

@@ -0,0 +1,27 @@
+import test from 'ava';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { androidPackageParser } from './androidPackageParser.js';
+import { fetchCid } from './fetchCid.js';
+
+const androidPackageMacro = test.macro({
+	title: (providedTitle, androidPackageCid: string) => providedTitle ?? `androidPackage ${androidPackageCid}`,
+	async exec(t, androidPackageCid: string) {
+		const androidPackageStream = await fetchCid(androidPackageCid);
+
+		const actual = await runParser(androidPackageParser, androidPackageStream, uint8ArrayParserInputCompanion, {
+			errorJoinMode: 'all',
+		});
+
+		for (const entry of actual.entries) {
+			if (entry.type === 'file') {
+				entry.content = new Uint8Array([ entry.content.length ]);
+			}
+		}
+
+		t.snapshot(actual);
+	},
+});
+
+test(androidPackageMacro, 'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu');
+test(androidPackageMacro, 'bafkreidqycbgrtp7ywhevsgtm464dqpamxsijpaqfcfz2k3ymc3wrzsb5m');

package/src/{apkParser.test.ts.md → androidPackageParser.test.ts.md}

@@ -1,10 +1,10 @@
-# Snapshot report for `src/apkParser.test.ts`
+# Snapshot report for `src/androidPackageParser.test.ts`
 
-The actual snapshot is saved in `apkParser.test.ts.snap`.
+The actual snapshot is saved in `androidPackageParser.test.ts.snap`.
 
 Generated by [AVA](https://avajs.dev).
 
-## apk bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu
+## androidPackage bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu
 
 > Snapshot 1
 
@@ -189,7 +189,7 @@ Generated by [AVA](https://avajs.dev).
       },
     }
 
-## apk bafkreidqycbgrtp7ywhevsgtm464dqpamxsijpaqfcfz2k3ymc3wrzsb5m
+## androidPackage bafkreidqycbgrtp7ywhevsgtm464dqpamxsijpaqfcfz2k3ymc3wrzsb5m
 
 > Snapshot 1