acker-dacker 0.1.0 → 0.2.0

package/src/gitignore.ts

@@ -1,139 +0,0 @@
-import path from 'node:path';
-import { globPatternToRegexSource, isPathWithin, normalizeArchivePath } from './path-patterns';
-
-type GitIgnoreRule = {
-    readonly directoryOnly: boolean;
-    readonly matcher: RegExp;
-    readonly negated: boolean;
-};
-
-const parseGitIgnoreRule = (line: string): GitIgnoreRule | null => {
-    let pattern = line.replace(/[ \t]+$/u, '');
-    if (pattern.length === 0 || pattern.startsWith('#')) {
-        return null;
-    }
-
-    const escapedLeadingMarker = pattern.startsWith('\\#') || pattern.startsWith('\\!');
-    if (escapedLeadingMarker) {
-        pattern = pattern.slice(1);
-    }
-
-    let negated = false;
-    if (!escapedLeadingMarker && pattern.startsWith('!')) {
-        negated = true;
-        pattern = pattern.slice(1);
-    }
-
-    const directoryOnly = pattern.endsWith('/') && !pattern.endsWith('\\/');
-    if (directoryOnly) {
-        pattern = pattern.slice(0, -1);
-    }
-
-    const anchored = pattern.startsWith('/');
-    if (anchored) {
-        pattern = pattern.slice(1);
-    }
-    if (pattern.length === 0) {
-        return null;
-    }
-
-    const hasSlash = pattern.includes('/');
-    const source = globPatternToRegexSource(pattern);
-    const matcher = new RegExp(anchored || hasSlash ? `^${source}$` : `(?:^|/)${source}(?:$|/)`);
-
-    return { directoryOnly, matcher, negated };
-};
-
-const parseGitIgnoreRules = (contents: string): readonly GitIgnoreRule[] => {
-    const rules: GitIgnoreRule[] = [];
-    for (const line of contents.split(/\r?\n/u)) {
-        const rule = parseGitIgnoreRule(line);
-        if (rule) {
-            rules.push(rule);
-        }
-    }
-    return rules;
-};
-
-const matchesGitIgnoreRule = (rule: GitIgnoreRule, relativePath: string, isDirectory: boolean): boolean => {
-    if (!rule.directoryOnly || isDirectory) {
-        return rule.matcher.test(relativePath);
-    }
-
-    const segments = relativePath.split('/');
-    for (let end = 1; end < segments.length; end += 1) {
-        if (rule.matcher.test(segments.slice(0, end).join('/'))) {
-            return true;
-        }
-    }
-    return false;
-};
-
-export class GitIgnoreMatcher {
-    private readonly rulesByDirectory = new Map<string, readonly GitIgnoreRule[]>();
-
-    public constructor(private readonly rootDir: string) {}
-
-    private async rulesForDirectory(directory: string): Promise<readonly GitIgnoreRule[]> {
-        const cachedRules = this.rulesByDirectory.get(directory);
-        if (cachedRules) {
-            return cachedRules;
-        }
-
-        const ignoreFile = Bun.file(path.join(directory, '.gitignore'));
-        if (!(await ignoreFile.exists())) {
-            this.rulesByDirectory.set(directory, []);
-            return [];
-        }
-
-        try {
-            const rules = parseGitIgnoreRules(await ignoreFile.text());
-            this.rulesByDirectory.set(directory, rules);
-            return rules;
-        } catch {
-            this.rulesByDirectory.set(directory, []);
-            return [];
-        }
-    }
-
-    public async isIgnored(absolutePath: string, isDirectory: boolean): Promise<boolean> {
-        const parentDirectory = path.dirname(absolutePath);
-        if (!isPathWithin(parentDirectory, this.rootDir)) {
-            return false;
-        }
-
-        const directories: string[] = [];
-        let directory = parentDirectory;
-        while (true) {
-            directories.push(directory);
-            if (directory === this.rootDir) {
-                break;
-            }
-
-            const parent = path.dirname(directory);
-            if (parent === directory || !isPathWithin(parent, this.rootDir)) {
-                return false;
-            }
-            directory = parent;
-        }
-
-        directories.reverse();
-
-        let ignored = false;
-        for (const ruleDirectory of directories) {
-            const relativePath = normalizeArchivePath(path.relative(ruleDirectory, absolutePath));
-            if (relativePath.length === 0 || relativePath === '..' || relativePath.startsWith('../')) {
-                continue;
-            }
-
-            const rules = await this.rulesForDirectory(ruleDirectory);
-            for (const rule of rules) {
-                if (matchesGitIgnoreRule(rule, relativePath, isDirectory)) {
-                    ignored = !rule.negated;
-                }
-            }
-        }
-
-        return ignored;
-    }
-}

package/src/zip.ts

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