acker-dacker 0.1.0

package/src/zip.ts

@@ -0,0 +1,327 @@
+import { lstat, mkdir, open, readdir, readlink } from 'node:fs/promises';
+import path from 'node:path';
+import { deflateRawSync } from 'node:zlib';
+import { compareStableStrings, normalizeArchivePath } from './path-patterns';
+
+type ZipEntryKind = 'file' | 'symlink';
+
+type ZipFileEntry = {
+    readonly absolutePath: string;
+    readonly archivePath: string;
+    readonly kind: ZipEntryKind;
+    readonly linkTarget?: string;
+    readonly mode?: number;
+    readonly size: number;
+};
+
+type WrittenZipEntry = ZipFileEntry & {
+    readonly compressedSize: number;
+    readonly compressionMethod: number;
+    readonly crc32: number;
+    readonly localHeaderOffset: number;
+    readonly pathBytes: Uint8Array;
+};
+
+export type ZipCreationOptions = {
+    readonly preserveSymlinks: boolean;
+    readonly preserveUnixMetadata: boolean;
+};
+
+const ZIP_MAX_UINT32 = 0xffffffff;
+const ZIP_MAX_UINT16 = 0xffff;
+const ZIP_DOS_DATE_1980_01_01 = 0x21;
+const ZIP_DEFLATE_METHOD = 8;
+const ZIP_STORE_METHOD = 0;
+const ZIP_UNIX_CREATOR_VERSION = 0x0314;
+const MAX_BUFFERED_DEFLATE_BYTES = 64 * 1024 * 1024;
+
+const CRC32_TABLE = new Uint32Array(256);
+for (let index = 0; index < CRC32_TABLE.length; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+        value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    CRC32_TABLE[index] = value >>> 0;
+}
+
+const updateCrc32 = (crc: number, chunk: Uint8Array): number => {
+    let current = crc;
+    for (const byte of chunk) {
+        current = CRC32_TABLE[(current ^ byte) & 0xff]! ^ (current >>> 8);
+    }
+    return current >>> 0;
+};
+
+const collectZipFiles = async ({
+    directory,
+    excludedAbsolutePath,
+    preserveSymlinks,
+    preserveUnixMetadata,
+    rootDir,
+}: {
+    readonly directory: string;
+    readonly excludedAbsolutePath: string;
+    readonly preserveSymlinks: boolean;
+    readonly preserveUnixMetadata: boolean;
+    readonly rootDir: string;
+}): Promise<readonly ZipFileEntry[]> => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files: ZipFileEntry[] = [];
+    for (const entry of entries.sort((left, right) => compareStableStrings(left.name, right.name))) {
+        const absolutePath = path.join(directory, entry.name);
+        if (absolutePath === excludedAbsolutePath) {
+            continue;
+        }
+
+        if (entry.isSymbolicLink()) {
+            if (!preserveSymlinks) {
+                continue;
+            }
+            const linkTarget = await readlink(absolutePath);
+            files.push({
+                absolutePath,
+                archivePath: normalizeArchivePath(path.relative(rootDir, absolutePath)),
+                kind: 'symlink',
+                linkTarget,
+                mode: 0o120777,
+                size: new TextEncoder().encode(linkTarget).byteLength,
+            });
+            continue;
+        }
+
+        if (entry.isDirectory()) {
+            files.push(
+                ...(await collectZipFiles({
+                    directory: absolutePath,
+                    excludedAbsolutePath,
+                    preserveSymlinks,
+                    preserveUnixMetadata,
+                    rootDir,
+                })),
+            );
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+
+        const fileStats = await lstat(absolutePath);
+        if (fileStats.size > ZIP_MAX_UINT32) {
+            throw new Error(`Zip entry exceeds 4 GB limit: ${absolutePath}`);
+        }
+        files.push({
+            absolutePath,
+            archivePath: normalizeArchivePath(path.relative(rootDir, absolutePath)),
+            kind: 'file',
+            mode: preserveUnixMetadata ? fileStats.mode : undefined,
+            size: fileStats.size,
+        });
+    }
+    return files;
+};
+
+const writeBuffer = async (
+    handle: Awaited<ReturnType<typeof open>>,
+    buffer: Uint8Array,
+    offset: number,
+): Promise<number> => {
+    await handle.write(buffer, 0, buffer.length, offset);
+    return offset + buffer.length;
+};
+
+const writeZipLocalHeader = async (
+    handle: Awaited<ReturnType<typeof open>>,
+    entry: ZipFileEntry,
+    pathBytes: Uint8Array,
+    crc32: number,
+    compressedSize: number,
+    compressionMethod: number,
+    offset: number,
+): Promise<number> => {
+    const header = Buffer.alloc(30);
+    header.writeUInt32LE(0x04034b50, 0);
+    header.writeUInt16LE(20, 4);
+    header.writeUInt16LE(0, 6);
+    header.writeUInt16LE(compressionMethod, 8);
+    header.writeUInt16LE(0, 10);
+    header.writeUInt16LE(ZIP_DOS_DATE_1980_01_01, 12);
+    header.writeUInt32LE(crc32, 14);
+    header.writeUInt32LE(compressedSize, 18);
+    header.writeUInt32LE(entry.size, 22);
+    header.writeUInt16LE(pathBytes.length, 26);
+    header.writeUInt16LE(0, 28);
+    const nextOffset = await writeBuffer(handle, header, offset);
+    return await writeBuffer(handle, pathBytes, nextOffset);
+};
+
+const computeFileCrc32 = async (absolutePath: string): Promise<number> => {
+    const reader = Bun.file(absolutePath).stream().getReader();
+    let crc = 0xffffffff;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            crc = updateCrc32(crc, value);
+        }
+    } finally {
+        reader.releaseLock();
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+};
+
+const prepareFileBytes = async (entry: ZipFileEntry) => {
+    if (entry.kind === 'symlink') {
+        const source = new TextEncoder().encode(entry.linkTarget ?? '');
+        const compressed = deflateRawSync(source, { level: 9 });
+        if (compressed.byteLength >= source.byteLength) {
+            return {
+                bytes: source,
+                compressedSize: source.byteLength,
+                compressionMethod: ZIP_STORE_METHOD,
+                crc32: (updateCrc32(0xffffffff, source) ^ 0xffffffff) >>> 0,
+            };
+        }
+        return {
+            bytes: compressed,
+            compressedSize: compressed.byteLength,
+            compressionMethod: ZIP_DEFLATE_METHOD,
+            crc32: (updateCrc32(0xffffffff, source) ^ 0xffffffff) >>> 0,
+        };
+    }
+
+    if (entry.size > MAX_BUFFERED_DEFLATE_BYTES) {
+        return {
+            bytes: null,
+            compressedSize: entry.size,
+            compressionMethod: ZIP_STORE_METHOD,
+            crc32: await computeFileCrc32(entry.absolutePath),
+        };
+    }
+    const source = new Uint8Array(await Bun.file(entry.absolutePath).arrayBuffer());
+    const compressed = deflateRawSync(source, { level: 9 });
+    if (compressed.byteLength >= source.byteLength) {
+        return {
+            bytes: source,
+            compressedSize: source.byteLength,
+            compressionMethod: ZIP_STORE_METHOD,
+            crc32: (updateCrc32(0xffffffff, source) ^ 0xffffffff) >>> 0,
+        };
+    }
+    return {
+        bytes: compressed,
+        compressedSize: compressed.byteLength,
+        compressionMethod: ZIP_DEFLATE_METHOD,
+        crc32: (updateCrc32(0xffffffff, source) ^ 0xffffffff) >>> 0,
+    };
+};
+
+export const createZipFile = async (
+    rootDir: string,
+    outputFile: string,
+    options: ZipCreationOptions = { preserveSymlinks: false, preserveUnixMetadata: false },
+): Promise<void> => {
+    const absoluteOutputFile = path.resolve(outputFile);
+    const absoluteRootDir = path.resolve(rootDir);
+    await mkdir(path.dirname(absoluteOutputFile), { recursive: true });
+    const handle = await open(absoluteOutputFile, 'w');
+
+    try {
+        let offset = 0;
+        const writtenEntries: WrittenZipEntry[] = [];
+        const files = await collectZipFiles({
+            directory: absoluteRootDir,
+            excludedAbsolutePath: absoluteOutputFile,
+            preserveSymlinks: options.preserveSymlinks,
+            preserveUnixMetadata: options.preserveUnixMetadata,
+            rootDir: absoluteRootDir,
+        });
+
+        for (const entry of files) {
+            const pathBytes = new TextEncoder().encode(entry.archivePath);
+            if (pathBytes.length > ZIP_MAX_UINT16) {
+                throw new Error(`Path exceeds ZIP16 limit: ${entry.archivePath}`);
+            }
+
+            const prepared = await prepareFileBytes(entry);
+            const localHeaderOffset = offset;
+            offset = await writeZipLocalHeader(
+                handle,
+                entry,
+                pathBytes,
+                prepared.crc32,
+                prepared.compressedSize,
+                prepared.compressionMethod,
+                offset,
+            );
+
+            if (prepared.bytes) {
+                offset = await writeBuffer(handle, prepared.bytes, offset);
+            } else {
+                const reader = Bun.file(entry.absolutePath).stream().getReader();
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            break;
+                        }
+                        offset = await writeBuffer(handle, value, offset);
+                    }
+                } finally {
+                    reader.releaseLock();
+                }
+            }
+
+            writtenEntries.push({
+                ...entry,
+                compressedSize: prepared.compressedSize,
+                compressionMethod: prepared.compressionMethod,
+                crc32: prepared.crc32,
+                localHeaderOffset,
+                pathBytes,
+            });
+        }
+
+        const centralDirectoryOffset = offset;
+        for (const entry of writtenEntries) {
+            const header = Buffer.alloc(46);
+            header.writeUInt32LE(0x02014b50, 0);
+            header.writeUInt16LE(options.preserveUnixMetadata ? ZIP_UNIX_CREATOR_VERSION : 20, 4);
+            header.writeUInt16LE(20, 6);
+            header.writeUInt16LE(0, 8);
+            header.writeUInt16LE(entry.compressionMethod, 10);
+            header.writeUInt16LE(0, 12);
+            header.writeUInt16LE(ZIP_DOS_DATE_1980_01_01, 14);
+            header.writeUInt32LE(entry.crc32, 16);
+            header.writeUInt32LE(entry.compressedSize, 20);
+            header.writeUInt32LE(entry.size, 24);
+            header.writeUInt16LE(entry.pathBytes.length, 28);
+            header.writeUInt16LE(0, 30);
+            header.writeUInt16LE(0, 32);
+            header.writeUInt16LE(0, 34);
+            header.writeUInt16LE(0, 36);
+            const externalAttributes = options.preserveUnixMetadata
+                ? ((((entry.mode ?? 0o100644) & 0xffff) << 16) >>> 0)
+                : 0;
+            header.writeUInt32LE(externalAttributes, 38);
+            header.writeUInt32LE(entry.localHeaderOffset, 42);
+            offset = await writeBuffer(handle, header, offset);
+            offset = await writeBuffer(handle, entry.pathBytes, offset);
+        }
+
+        const centralDirectorySize = offset - centralDirectoryOffset;
+        const endHeader = Buffer.alloc(22);
+        endHeader.writeUInt32LE(0x06054b50, 0);
+        endHeader.writeUInt16LE(0, 4);
+        endHeader.writeUInt16LE(0, 6);
+        endHeader.writeUInt16LE(writtenEntries.length, 8);
+        endHeader.writeUInt16LE(writtenEntries.length, 10);
+        endHeader.writeUInt32LE(centralDirectorySize, 12);
+        endHeader.writeUInt32LE(centralDirectoryOffset, 16);
+        endHeader.writeUInt16LE(0, 20);
+        await writeBuffer(handle, endHeader, offset);
+    } finally {
+        await handle.close();
+    }
+};