@php-wasm/stream-compression 0.0.1 → 0.9.16

package/utils/iterator-to-stream.d.ts

@@ -0,0 +1,8 @@
+import { IterableReadableStream } from './iterable-stream-polyfill';
+/**
+ * Converts an iterator or iterable to a stream.
+ *
+ * @param iteratorOrIterable The iterator or iterable to convert.
+ * @returns A stream that will yield the values from the iterator or iterable.
+ */
+export declare function iteratorToStream<T>(iteratorOrIterable: AsyncIterator<T> | Iterator<T> | AsyncIterable<T> | Iterable<T>): IterableReadableStream<T>;

package/utils/limit-bytes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Limit the number of bytes read from a stream.
+ *
+ * @param stream The stream to limit.
+ * @param bytes The number of bytes to read from the stream.
+ * @returns A new stream that will read at most `bytes` bytes from `stream`.
+ */
+export declare function limitBytes(stream: ReadableStream<Uint8Array>, bytes: number): ReadableStream<any>;

package/utils/prepend-bytes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prepend bytes to a stream.
+ *
+ * @param bytes The bytes to prepend.
+ * @returns A transform stream that will prepend the specified bytes.
+ */
+export declare function prependBytes(bytes: Uint8Array): TransformStream<Uint8Array, Uint8Array>;

package/utils/skip-first-bytes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Skips the first `length` bytes of a stream.
+ *
+ * @param length The number of bytes to skip.
+ * @returns A transform stream that will skip the specified number of bytes.
+ */
+export declare function skipFirstBytes(length: number): TransformStream<Uint8Array, Uint8Array>;

package/utils/skip-last-bytes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Skips the first `length` bytes of a stream.
+ *
+ * @param length The number of bytes to skip.
+ * @returns A transform stream that will skip the specified number of bytes.
+ */
+export declare function skipLastBytes(skip: number, streamLength: number): TransformStream<any, any>;

package/utils/streamed-file.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Represents a file that is streamed and not fully
+ * loaded into memory.
+ */
+export declare class StreamedFile extends File {
+    private readableStream;
+    /**
+     * Creates a new StreamedFile instance.
+     *
+     * @param readableStream The readable stream containing the file data.
+     * @param name The name of the file.
+     * @param type The MIME type of the file.
+     */
+    constructor(readableStream: ReadableStream<Uint8Array>, name: string, type?: string);
+    /**
+     * Overrides the slice() method of the File class.
+     *
+     * @returns A Blob representing a portion of the file.
+     */
+    slice(): Blob;
+    /**
+     * Returns the readable stream associated with the file.
+     *
+     * @returns The readable stream.
+     */
+    stream(): ReadableStream<Uint8Array>;
+    /**
+     * Loads the file data into memory and then returns it as a string.
+     *
+     * @returns File data as text.
+     */
+    text(): Promise<string>;
+    /**
+     * Loads the file data into memory and then returns it as an ArrayBuffer.
+     *
+     * @returns File data as an ArrayBuffer.
+     */
+    arrayBuffer(): Promise<Uint8Array>;
+}

package/zip/decode-remote-zip.d.ts

@@ -0,0 +1,14 @@
+import { CentralDirectoryEntry, FileEntry } from './types';
+import { IterableReadableStream } from '../utils/iterable-stream-polyfill';
+/**
+ * Streams the contents of a remote zip file.
+ *
+ * If the zip is large and the predicate is filtering the zip contents,
+ * only the matching files will be downloaded using the Range header
+ * (if supported by the server).
+ *
+ * @param url The URL of the zip file.
+ * @param predicate Optional. A function that returns true if the file should be downloaded.
+ * @returns A stream of zip entries.
+ */
+export declare function decodeRemoteZip(url: string, predicate?: (dirEntry: CentralDirectoryEntry | FileEntry) => boolean): Promise<IterableReadableStream<FileEntry> | IterableReadableStream<File>>;

package/zip/decode-zip.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Reads files from a stream of zip file bytes.
+ */
+import { IterableReadableStream } from '../utils/iterable-stream-polyfill';
+import { CentralDirectoryEntry, FileEntry } from './types';
+/**
+ * Unzips a stream of zip file bytes.
+ *
+ * @param stream A stream of zip file bytes.
+ * @param predicate Optional. A function that returns true if the file should be downloaded.
+ * @returns An iterable stream of File objects.
+ */
+export declare function decodeZip(stream: ReadableStream<Uint8Array>, predicate?: () => boolean): IterableReadableStream<File>;
+/**
+ * Parses a stream of zipped bytes into FileEntry informations.
+ *
+ * @param stream A stream of zip file bytes.
+ * @param predicate Optional. A function that returns true if the file should be downloaded.
+ * @returns An iterable stream of FileEntry objects.
+ */
+export declare function streamZippedFileEntries(stream: ReadableStream<Uint8Array>, predicate?: (dirEntry: CentralDirectoryEntry | FileEntry) => boolean): IterableReadableStream<FileEntry>;
+/**
+ * Reads a file entry from a zip file.
+ *
+ * The file entry is structured as follows:
+ *
+ * ```
+ * Offset	Bytes	Description
+ *   0		4	Local file header signature = 0x04034b50 (PK♥♦ or "PK\3\4")
+ *   4		2	Version needed to extract (minimum)
+ *   6		2	General purpose bit flag
+ *   8		2	Compression method; e.g. none = 0, DEFLATE = 8 (or "\0x08\0x00")
+ *   10		2	File last modification time
+ *   12		2	File last modification date
+ *   14		4	CRC-32 of uncompressed data
+ *   18		4	Compressed size (or 0xffffffff for ZIP64)
+ *   22		4	Uncompressed size (or 0xffffffff for ZIP64)
+ *   26		2	File name length (n)
+ *   28		2	Extra field length (m)
+ *   30		n	File name
+ *   30+n	m	Extra field
+ * ```
+ *
+ * @param stream
+ * @param skipSignature Do not consume the signature from the stream.
+ * @returns
+ */
+export declare function readFileEntry(stream: ReadableStream<Uint8Array>, skipSignature?: boolean): Promise<FileEntry | null>;
+/**
+ * Reads a central directory entry from a zip file.
+ *
+ * The central directory entry is structured as follows:
+ *
+ * ```
+ * Offset Bytes Description
+ *   0		4	Central directory file header signature = 0x02014b50
+ *   4		2	Version made by
+ *   6		2	Version needed to extract (minimum)
+ *   8		2	General purpose bit flag
+ *   10		2	Compression method
+ *   12		2	File last modification time
+ *   14		2	File last modification date
+ *   16		4	CRC-32 of uncompressed data
+ *   20		4	Compressed size (or 0xffffffff for ZIP64)
+ *   24		4	Uncompressed size (or 0xffffffff for ZIP64)
+ *   28		2	File name length (n)
+ *   30		2	Extra field length (m)
+ *   32		2	File comment length (k)
+ *   34		2	Disk number where file starts (or 0xffff for ZIP64)
+ *   36		2	Internal file attributes
+ *   38		4	External file attributes
+ *   42		4	Relative offset of local file header (or 0xffffffff for ZIP64). This is the number of bytes between the start of the first disk on which the file occurs, and the start of the local file header. This allows software reading the central directory to locate the position of the file inside the ZIP file.
+ *   46		n	File name
+ *   46+n	m	Extra field
+ *   46+n+m	k	File comment
+ * ```
+ *
+ * @param stream
+ * @param skipSignature
+ * @returns
+ */
+export declare function readCentralDirectoryEntry(stream: ReadableStream<Uint8Array>, skipSignature?: boolean): Promise<CentralDirectoryEntry | null>;

package/zip/encode-zip.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compresses the given files into a ZIP archive.
+ *
+ * @param files - An async or sync iterable of files to be compressed.
+ * @returns A readable stream of the compressed ZIP archive as Uint8Array chunks.
+ */
+export declare function encodeZip(files: AsyncIterable<File> | Iterable<File>): ReadableStream<Uint8Array>;

package/{src/zip/index.ts → zip/index.d.ts}

@@ -1,5 +1,3 @@
-import '../utils/iterable-stream-polyfill';
-
 export * from './decode-zip';
 export * from './decode-remote-zip';
 export * from './encode-zip';

package/zip/types.d.ts

@@ -0,0 +1,66 @@
+export declare const FILE_HEADER_SIZE = 32;
+export declare const SIGNATURE_FILE: 67324752;
+export declare const SIGNATURE_CENTRAL_DIRECTORY: 33639248;
+export declare const SIGNATURE_CENTRAL_DIRECTORY_END: 101010256;
+export declare const SIGNATURE_DATA_DESCRIPTOR: 134695760;
+export declare const COMPRESSION_NONE: 0;
+export declare const COMPRESSION_DEFLATE: 8;
+export type CompressionMethod = typeof COMPRESSION_NONE | typeof COMPRESSION_DEFLATE;
+export type ZipEntry = FileEntry | CentralDirectoryEntry | CentralDirectoryEndEntry;
+/**
+ * Data of the file entry header encoded in a ".zip" file.
+ */
+export interface FileHeader {
+    signature: typeof SIGNATURE_FILE;
+    version: number;
+    generalPurpose: number;
+    compressionMethod: CompressionMethod;
+    lastModifiedTime: number;
+    lastModifiedDate: number;
+    crc: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    path: Uint8Array;
+    extra: Uint8Array;
+}
+export interface FileEntry extends FileHeader {
+    isDirectory: boolean;
+    bytes: Uint8Array;
+}
+/**
+ * Data of the central directory entry encoded in a ".zip" file.
+ */
+export interface CentralDirectoryEntry {
+    signature: typeof SIGNATURE_CENTRAL_DIRECTORY;
+    versionCreated: number;
+    versionNeeded: number;
+    generalPurpose: number;
+    compressionMethod: CompressionMethod;
+    lastModifiedTime: number;
+    lastModifiedDate: number;
+    crc: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    diskNumber: number;
+    internalAttributes: number;
+    externalAttributes: number;
+    firstByteAt: number;
+    lastByteAt: number;
+    path: Uint8Array;
+    extra: Uint8Array;
+    fileComment: Uint8Array;
+    isDirectory: boolean;
+}
+/**
+ * Data of the central directory end entry encoded in a ".zip" file.
+ */
+export interface CentralDirectoryEndEntry {
+    signature: typeof SIGNATURE_CENTRAL_DIRECTORY_END;
+    numberOfDisks: number;
+    centralDirectoryStartDisk: number;
+    numberCentralDirectoryRecordsOnThisDisk: number;
+    numberCentralDirectoryRecords: number;
+    centralDirectorySize: number;
+    centralDirectoryOffset: number;
+    comment: Uint8Array;
+}

package/.eslintrc.json

@@ -1,18 +0,0 @@
-{
-	"extends": ["../../../.eslintrc.json"],
-	"ignorePatterns": ["!**/*"],
-	"overrides": [
-		{
-			"files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-			"rules": {}
-		},
-		{
-			"files": ["*.ts", "*.tsx"],
-			"rules": {}
-		},
-		{
-			"files": ["*.js", "*.jsx"],
-			"rules": {}
-		}
-	]
-}

package/project.json

@@ -1,34 +0,0 @@
-{
-	"name": "php-wasm-stream-compression",
-	"$schema": "../../../node_modules/nx/schemas/project-schema.json",
-	"sourceRoot": "packages/php-wasm/stream-compression/src",
-	"projectType": "library",
-	"targets": {
-		"build": {
-			"executor": "@nx/vite:build",
-			"outputs": ["{options.outputPath}"],
-			"options": {
-				"outputPath": "dist/packages/php-wasm/stream-compression"
-			}
-		},
-		"test": {
-			"executor": "@nx/vite:test",
-			"outputs": ["{options.reportsDirectory}"],
-			"options": {
-				"passWithNoTests": true,
-				"reportsDirectory": "../../../coverage/packages/php-wasm/stream-compression"
-			}
-		},
-		"lint": {
-			"executor": "@nx/linter:eslint",
-			"outputs": ["{options.outputFile}"],
-			"options": {
-				"lintFilePatterns": [
-					"packages/php-wasm/stream-compression/**/*.ts",
-					"packages/php-wasm/stream-compression/package.json"
-				]
-			}
-		}
-	},
-	"tags": ["scope:independent-from-php-binaries"]
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-import '@php-wasm/node-polyfills';
-
-export { collectBytes } from './utils/collect-bytes';
-export { collectFile } from './utils/collect-file';
-export { iteratorToStream } from './utils/iterator-to-stream';
-export { StreamedFile } from './utils/streamed-file';
-export { encodeZip, decodeZip, decodeRemoteZip } from './zip';

package/src/test/append-bytes.spec.ts

@@ -1,25 +0,0 @@
-import { appendBytes } from '../utils/append-bytes';
-
-describe('appendBytes', () => {
-	it('Should append the specified number of bytes', async () => {
-		const stream = new ReadableStream<Uint8Array>({
-			type: 'bytes',
-			start(controller) {
-				controller.enqueue(new Uint8Array([1, 2, 3]));
-				controller.close();
-			},
-		}).pipeThrough(appendBytes(new Uint8Array([4, 5])));
-
-		const reader = stream.getReader();
-		const result1 = await reader.read();
-		expect(result1.value).toEqual(new Uint8Array([1, 2, 3]));
-		expect(result1.done).toBe(false);
-
-		const result2 = await reader.read();
-		expect(result2.value).toEqual(new Uint8Array([4, 5]));
-		expect(result2.done).toBe(false);
-
-		const result3 = await reader.read();
-		expect(result3.done).toBe(true);
-	});
-});

package/src/test/decode-zip.spec.ts

@@ -1,22 +0,0 @@
-import { decodeZip } from '../zip/decode-zip';
-import { readFile } from 'fs/promises';
-
-describe('decodeZip', () => {
-	it('Should uncompress compress files', async () => {
-		const zipBytes = await readFile(
-			__dirname + '/fixtures/hello-dolly.zip'
-		);
-		const zipStream = decodeZip(new Blob([zipBytes]).stream());
-
-		const files = [];
-		for await (const file of zipStream) {
-			files.push(file);
-		}
-		expect(files.length).toBe(3);
-		expect(files[0].name).toBe('hello-dolly/');
-		expect(files[1].name).toBe('hello-dolly/hello.php');
-		expect(files[1].size).toBe(2593);
-		expect(files[2].name).toBe('hello-dolly/readme.txt');
-		expect(files[2].size).toBe(624);
-	});
-});

package/src/test/encode-zip.spec.ts

@@ -1,47 +0,0 @@
-import { collectBytes } from '../utils/collect-bytes';
-import { encodeZip } from '../zip/encode-zip';
-import { decodeZip } from '../zip/decode-zip';
-
-describe('compressFiles', () => {
-	it('Should compress files into a zip archive', async () => {
-		const files: File[] = [
-			new File(
-				[new Uint8Array([1, 2, 3, 4, 5])],
-				'wp-content/plugins/hello.php'
-			),
-			new File(
-				[new Uint8Array([1, 2, 3, 4, 5])],
-				'wp-content/plugins/hello/hello.php'
-			),
-			new File(
-				[new Uint8Array([1, 2, 3, 4, 5])],
-				'wp-content/plugins/hello/hello2.php'
-			),
-			new File(
-				[new Uint8Array([1, 2, 3, 4, 5])],
-				'wp-content/plugins/hello/hello3.php'
-			),
-		];
-
-		const zipBytes = await collectBytes(
-			encodeZip(files[Symbol.iterator]())
-		);
-		const zipStream = decodeZip(new Blob([zipBytes!]).stream());
-
-		const reader = zipStream.getReader();
-		let i = 0;
-		for (i = 0; i < files.length; i++) {
-			const { value: receivedFile, done } = await reader.read();
-			const receivedBytes = new Uint8Array(
-				await receivedFile!.arrayBuffer()
-			);
-			const expectedBytes = new Uint8Array(await files[i].arrayBuffer());
-			expect(receivedBytes).toEqual(expectedBytes);
-			expect(done).toBe(false);
-		}
-		expect(i).toBe(files.length);
-
-		const { done } = await reader.read();
-		expect(done).toBe(true);
-	});
-});

package/src/test/prepend-bytes.spec.ts

@@ -1,25 +0,0 @@
-import { prependBytes } from '../utils/prepend-bytes';
-
-describe('prependBytes', () => {
-	it('Should prepend the specified number of bytes', async () => {
-		const stream = new ReadableStream<Uint8Array>({
-			type: 'bytes',
-			start(controller) {
-				controller.enqueue(new Uint8Array([4, 5]));
-				controller.close();
-			},
-		}).pipeThrough(prependBytes(new Uint8Array([1, 2, 3])));
-
-		const reader = stream.getReader();
-		const result1 = await reader.read();
-		expect(result1.value).toEqual(new Uint8Array([1, 2, 3]));
-		expect(result1.done).toBe(false);
-
-		const result2 = await reader.read();
-		expect(result2.value).toEqual(new Uint8Array([4, 5]));
-		expect(result2.done).toBe(false);
-
-		const result3 = await reader.read();
-		expect(result3.done).toBe(true);
-	});
-});

package/src/test/skip-first-bytes.spec.ts

@@ -1,41 +0,0 @@
-import { skipFirstBytes } from '../utils/skip-first-bytes';
-
-describe('skipFirstBytes', () => {
-	it('Should skip the specified number of bytes', async () => {
-		const stream = new ReadableStream<Uint8Array>({
-			type: 'bytes',
-			start(controller) {
-				controller.enqueue(new Uint8Array([1, 2, 3, 4, 5]));
-				controller.close();
-			},
-		}).pipeThrough(skipFirstBytes(3));
-
-		const reader = stream.getReader();
-		const result1 = await reader.read();
-		expect(result1.value).toEqual(new Uint8Array([4, 5]));
-		expect(result1.done).toBe(false);
-
-		const result2 = await reader.read();
-		expect(result2.done).toBe(true);
-	});
-
-	it('Should skip the specified number of bytes across multiple pulls', async () => {
-		const stream = new ReadableStream<Uint8Array>({
-			type: 'bytes',
-			start(controller) {
-				controller.enqueue(new Uint8Array([1]));
-				controller.enqueue(new Uint8Array([2, 3]));
-				controller.enqueue(new Uint8Array([4, 5, 6]));
-				controller.close();
-			},
-		}).pipeThrough(skipFirstBytes(4));
-
-		const reader = stream.getReader();
-		const result1 = await reader.read();
-		expect(result1.value).toEqual(new Uint8Array([5, 6]));
-		expect(result1.done).toBe(false);
-
-		const result2 = await reader.read();
-		expect(result2.done).toBe(true);
-	});
-});

package/src/test/skip-last-bytes.spec.ts

@@ -1,27 +0,0 @@
-import { skipLastBytes } from '../utils/skip-last-bytes';
-
-describe('skipLastBytes', () => {
-	it('Should skip the specified number of bytes', async () => {
-		const stream = new ReadableStream<Uint8Array>({
-			type: 'bytes',
-			start(controller) {
-				controller.enqueue(new Uint8Array([1, 2, 3, 4, 5]));
-				controller.enqueue(new Uint8Array([6, 7]));
-				controller.enqueue(new Uint8Array([8, 9]));
-				controller.close();
-			},
-		}).pipeThrough(skipLastBytes(3, 9));
-
-		const reader = stream.getReader();
-		const result1 = await reader.read();
-		expect(result1.value).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
-		expect(result1.done).toBe(false);
-
-		const result2 = await reader.read();
-		expect(result2.value).toEqual(new Uint8Array([6]));
-		expect(result2.done).toBe(false);
-
-		const result3 = await reader.read();
-		expect(result3.done).toBe(true);
-	});
-});

package/src/utils/append-bytes.ts

@@ -1,16 +0,0 @@
-/**
- * Appends bytes to a stream.
- *
- * @param bytes The bytes to append.
- * @returns A transform stream that will append the specified bytes.
- */
-export function appendBytes(bytes: Uint8Array) {
-	return new TransformStream<Uint8Array, Uint8Array>({
-		async transform(chunk, controller) {
-			controller.enqueue(chunk);
-		},
-		async flush(controller) {
-			controller.enqueue(bytes);
-		},
-	});
-}

package/src/utils/collect-bytes.ts

@@ -1,24 +0,0 @@
-import { concatBytes } from './concat-bytes';
-import { limitBytes } from './limit-bytes';
-
-/**
- * Collects the contents of the entire stream into a single Uint8Array.
- *
- * @param stream The stream to collect.
- * @param bytes Optional. The number of bytes to read from the stream.
- * @returns The string contents of the stream.
- */
-export async function collectBytes(
-	stream: ReadableStream<Uint8Array>,
-	bytes?: number
-) {
-	if (bytes !== undefined) {
-		stream = limitBytes(stream, bytes);
-	}
-
-	return await stream
-		.pipeThrough(concatBytes(bytes))
-		.getReader()
-		.read()
-		.then(({ value }) => value!);
-}

package/src/utils/collect-file.ts

@@ -1,16 +0,0 @@
-import { collectBytes } from './collect-bytes';
-
-/**
- * Collects the contents of the entire stream into a single File object.
- *
- * @param stream The stream to collect.
- * @param fileName The name of the file
- * @returns The string contents of the stream.
- */
-export async function collectFile(
-	fileName: string,
-	stream: ReadableStream<Uint8Array>
-) {
-	// @TODO: use StreamingFile
-	return new File([await collectBytes(stream)], fileName);
-}

package/src/utils/collect-string.ts

@@ -1,25 +0,0 @@
-import { concatString } from './concat-string';
-import { limitBytes } from './limit-bytes';
-
-/**
- * Collects the contents of the entire stream into a single string.
- *
- * @param stream The stream to collect.
- * @param bytes Optional. The number of bytes to read from the stream.
- * @returns The string contents of the stream.
- */
-export async function collectString(
-	stream: ReadableStream<Uint8Array>,
-	bytes?: number
-) {
-	if (bytes !== undefined) {
-		stream = limitBytes(stream, bytes);
-	}
-
-	return await stream
-		.pipeThrough(new TextDecoderStream())
-		.pipeThrough(concatString())
-		.getReader()
-		.read()
-		.then(({ value }) => value);
-}

package/src/utils/concat-bytes.ts

@@ -1,38 +0,0 @@
-import { concatUint8Array } from './concat-uint8-array';
-
-/**
- * Concatenates the contents of the stream into a single Uint8Array.
- *
- * @param totalBytes Optional. The number of bytes to concatenate. Used to
- *  				 pre-allocate the buffer. If not provided, the buffer will
- * 				     be dynamically resized as needed.
- * @returns A stream that will emit a single UInt8Array entry before closing.
- */
-export function concatBytes(totalBytes?: number) {
-	if (totalBytes === undefined) {
-		let acc = new Uint8Array();
-		return new TransformStream<Uint8Array, Uint8Array>({
-			transform(chunk) {
-				acc = concatUint8Array(acc, chunk);
-			},
-
-			flush(controller) {
-				controller.enqueue(acc);
-			},
-		});
-	} else {
-		const buffer = new ArrayBuffer(totalBytes || 0);
-		let offset = 0;
-		return new TransformStream<Uint8Array, Uint8Array>({
-			transform(chunk) {
-				const view = new Uint8Array(buffer);
-				view.set(chunk, offset);
-				offset += chunk.byteLength;
-			},
-
-			flush(controller) {
-				controller.enqueue(new Uint8Array(buffer));
-			},
-		});
-	}
-}

package/src/utils/concat-string.ts

@@ -1,17 +0,0 @@
-/**
- * Concatenate all chunks into a single string.
- *
- * @returns A stream that will emit a single string entry before closing.
- */
-export function concatString() {
-	const chunks: string[] = [];
-	return new TransformStream<string, string>({
-		transform(chunk) {
-			chunks.push(chunk);
-		},
-
-		flush(controller) {
-			controller.enqueue(chunks.join(''));
-		},
-	});
-}