7zip-native 0.0.8 → 0.0.12

package/dist/index.mjs

@@ -1,10 +1,10 @@
-import { existsSync, createWriteStream } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { rename, link, rm, lstat, mkdir } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { availableParallelism } from 'node:os';
 import { dirname, resolve, join, extname, relative, sep } from 'node:path';
-import { Readable, Transform } from 'node:stream';
+import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 
 class ArchiveError extends Error {
@@ -17,6 +17,9 @@ class ArchiveError extends Error {
 }
 
 const defaultMaxOutputBytes = 4n * 1024n * 1024n * 1024n;
+const defaultDeflateBufferSize = 32 * 1024;
+const minDeflateBufferSize = 4 * 1024;
+const maxDeflateBufferSize = 2 * 1024 * 1024;
 function normalizeMaxBytes(value, label) {
     if (value === undefined) {
         return defaultMaxOutputBytes;
@@ -60,32 +63,44 @@ function safeEntrySegments(entryPath) {
         throw new ArchiveError('ERR_ARCHIVE_PATH', 'Archive entry path contains a null byte');
     }
     const normalized = entryPath.replace(/\\/g, '/');
-    if (normalized.startsWith('/') || /^[a-zA-Z]:/.test(normalized)) {
+    if (normalized.startsWith('/') || /^[a-zA-Z]:\//.test(normalized)) {
         throw new ArchiveError('ERR_ARCHIVE_PATH', `Archive entry path is absolute: ${entryPath}`);
     }
     const segments = normalized.split('/').filter(segment => segment !== '' && segment !== '.');
-    if (segments.length === 0 || segments.some(segment => segment === '..'
-        || segment.includes(':')
-        || /[. ]$/.test(segment)
-        || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(segment))) {
+    if (segments.length === 0 || segments.some(segment => segment === '..')) {
         throw new ArchiveError('ERR_ARCHIVE_PATH', `Unsafe archive entry path: ${entryPath}`);
     }
     return segments;
 }
+function sanitizeWindowsSegment(segment) {
+    if (segment === '.' || segment === '..') {
+        return segment;
+    }
+    const sanitized = [...segment].map(character => character.charCodeAt(0) < 0x20 || '<>:|?*"'.includes(character) ? '_' : character).join('')
+        .replace(/[. ]+$/g, trailing => '_'.repeat(trailing.length));
+    const reservedName = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])/i.exec(sanitized);
+    if (reservedName) {
+        let index = reservedName[0].length;
+        while (sanitized[index] === ' ') {
+            index++;
+        }
+        if (index === sanitized.length || sanitized[index] === '.') {
+            return `_${sanitized}`;
+        }
+    }
+    return sanitized;
+}
 function sanitizeOutputPath(entryPath) {
     if (process.platform !== 'win32') {
         return entryPath;
     }
-    return entryPath
-        .replace(/([. ]+)([\\/]|$)/g, (_match, unsupported, separator) => '_'.repeat(unsupported.length) + separator)
-        .replace(/[<>:|?*"]/g, '_');
+    return entryPath.replace(/\\/g, '/').split('/').map(sanitizeWindowsSegment).join('/');
 }
 function assertSafeRelativeArchivePath(entryPath) {
     const normalized = entryPath.replace(/\\/g, '/');
     const segments = normalized.split('/').filter(segment => segment !== '' && segment !== '.');
-    if (entryPath.includes('\0')
-        || normalized.startsWith('/')
-        || /^[a-zA-Z]:/.test(normalized)
+    if (normalized.startsWith('/')
+        || /^[a-zA-Z]:\//.test(normalized)
         || segments.length === 0
         || segments.some(segment => segment === '..')) {
         throw new ArchiveError('ERR_ARCHIVE_PATH', `Unsafe archive entry path: ${entryPath}`);
@@ -156,6 +171,19 @@ async function assertReplaceableOutput(filePath) {
         }
     }
 }
+async function assertFolderOutputDoesNotExist(filePath) {
+    try {
+        await lstat(filePath);
+        const error = new Error(`Output file already exists: ${filePath}`);
+        Object.assign(error, { code: 'EEXIST' });
+        throw error;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
 async function assertOutputDoesNotExist(filePath) {
     try {
         await lstat(filePath);
@@ -185,7 +213,7 @@ async function normalizeCreateEntry(entry) {
     if (details.isSymbolicLink() || !details.isFile()) {
         throw new ArchiveError('ERR_ARCHIVE_CREATE', `Archive creation source is not a regular file: ${sourcePath}`);
     }
-    return { sourcePath, path: internalPath };
+    return { sourcePath, path: internalPath, mtimeMs: details.mtimeMs };
 }
 async function ensureExtractionRoot(root) {
     try {
@@ -315,6 +343,7 @@ class Archive {
     handle;
     closed = false;
     entriesPromise;
+    entryIndexes;
     constructor(handle) {
         this.handle = handle;
     }
@@ -339,8 +368,14 @@ class Archive {
                 throw new RangeError('Password exceeds the 1 MiB native password limit');
             }
         }
+        const deflateBufferSize = options.deflateBufferSize ?? defaultDeflateBufferSize;
+        if (!Number.isSafeInteger(deflateBufferSize)
+            || deflateBufferSize < minDeflateBufferSize
+            || deflateBufferSize > maxDeflateBufferSize) {
+            throw new RangeError(`Deflate buffer size must be an integer between ${minDeflateBufferSize} and ${maxDeflateBufferSize} bytes`);
+        }
         try {
-            const handle = await native.open(resolve(path), options.password, enginePath);
+            const handle = await native.open(resolve(path), options.password, enginePath, deflateBufferSize);
             return new Archive(handle);
         }
         catch (cause) {
@@ -452,7 +487,23 @@ class Archive {
         if (typeof idOrPath === 'number' && (!Number.isSafeInteger(idOrPath) || idOrPath < 0)) {
             throw new RangeError('Entry ID must be a non-negative safe integer');
         }
-        return (await this.entries()).find(entry => typeof idOrPath === 'number' ? entry.id === idOrPath : entry.path === idOrPath);
+        const entries = await this.entries();
+        if (!this.entryIndexes) {
+            const pathEntries = Object.create(null);
+            const idEntries = Object.create(null);
+            for (const entry of entries) {
+                pathEntries[entry.path] ??= entry;
+                idEntries[entry.id] ??= entry;
+            }
+            this.entryIndexes = { pathEntries, idEntries };
+        }
+        if (typeof idOrPath === 'number') {
+            return this.entryIndexes.idEntries[idOrPath];
+        }
+        if (typeof idOrPath === 'string') {
+            return this.entryIndexes.pathEntries[idOrPath];
+        }
+        return undefined;
     }
     async extract(idOrPathOrPaths) {
         this.assertOpen();
@@ -530,9 +581,6 @@ class Archive {
                 || options.concurrency > 128)) {
             throw new RangeError('Folder extraction concurrency must be an integer between 1 and 128');
         }
-        if (options.onProgress !== undefined && typeof options.onProgress !== 'function') {
-            throw new TypeError('Folder extraction onProgress option must be a function');
-        }
         if (options.onExtract !== undefined && typeof options.onExtract !== 'function') {
             throw new TypeError('Folder extraction onExtract option must be a function');
         }
@@ -575,33 +623,13 @@ class Archive {
         }
         const root = resolve(destination);
         const plans = makeOutputPlans(root, selectedEntries);
-        const expectedBytes = selectedEntries.reduce((total, entry) => total + (entry.isDirectory ? 0n : entry.size), 0n);
-        if (maxBytes !== null && expectedBytes > maxBytes) {
+        const totalBytes = selectedEntries.reduce((total, entry) => total + (entry.isDirectory ? 0n : entry.size), 0n);
+        if (maxBytes !== null && totalBytes > maxBytes) {
             throw new ArchiveError('ERR_RESOURCE_LIMIT', `Folder output exceeds the ${maxBytes}-byte limit`);
         }
         options.signal?.throwIfAborted();
         await ensureExtractionRoot(root);
-        let extractedBytes = 0n;
         let filesExtracted = 0;
-        const totalFiles = plans.filter(plan => !plan.isDirectory).length;
-        const reportProgress = () => {
-            let percent = 0;
-            if (expectedBytes > 0n) {
-                const scaledPercent = extractedBytes * 10000n / expectedBytes;
-                percent = Number(scaledPercent > 9900n ? 9900n : scaledPercent) / 100;
-            }
-            if (filesExtracted === totalFiles) {
-                percent = 100;
-            }
-            options.onProgress?.({
-                filesExtracted,
-                totalFiles,
-                bytesProcessed: extractedBytes,
-                totalBytes: expectedBytes,
-                percent,
-            });
-        };
-        reportProgress();
         for (const plan of plans) {
             options.signal?.throwIfAborted();
             if (plan.isDirectory) {
@@ -613,7 +641,6 @@ class Archive {
         const extractionSignal = controller.signal;
         let hasFailure = false;
         let failure;
-        let nextFileIndex = 0;
         const stop = (error) => {
             if (!hasFailure) {
                 hasFailure = true;
@@ -627,78 +654,77 @@ class Archive {
             stop(options.signal?.reason);
         };
         options.signal?.addEventListener('abort', abortFromCaller, { once: true });
-        const extractFile = async (plan) => {
-            await ensureOutputParents(root, plan.targetPath);
-            const limit = new Transform({
-                transform(chunk, _encoding, callback) {
-                    const size = BigInt(chunk.length);
-                    if (maxBytes !== null && extractedBytes + size > maxBytes) {
-                        callback(new ArchiveError('ERR_RESOURCE_LIMIT', `Folder output exceeds the ${maxBytes}-byte limit`));
-                        return;
-                    }
-                    extractedBytes += size;
-                    try {
-                        reportProgress();
+        const groupCount = Math.min(concurrency, filePlans.length);
+        const fileGroups = Array.from({ length: groupCount }, () => []);
+        filePlans.forEach((plan, index) => {
+            fileGroups[index % groupCount].push(plan);
+        });
+        const extractGroup = async (group) => {
+            const outputs = [];
+            let completionFailed = false;
+            let completionFailure;
+            try {
+                for (const plan of group) {
+                    await ensureOutputParents(root, plan.targetPath);
+                    extractionSignal.throwIfAborted();
+                    if (options.overwrite) {
+                        await assertReplaceableOutput(plan.targetPath);
                     }
-                    catch (error) {
-                        callback(error instanceof Error ? error : new Error(String(error)));
-                        return;
+                    else {
+                        await assertFolderOutputDoesNotExist(plan.targetPath);
                     }
-                    callback(null, chunk);
-                },
-            });
-            if (options.overwrite) {
-                await assertReplaceableOutput(plan.targetPath);
-                const temporaryPath = join(dirname(plan.targetPath), `.7zip-native-${randomUUID()}.tmp`);
-                try {
-                    await pipeline(this.createReadStream(plan.entry.id, {
-                        signal: extractionSignal,
-                        maxBytes: null,
-                    }), limit, createWriteStream(temporaryPath, { flags: 'wx', mode: 0o600 }), { signal: extractionSignal });
-                    extractionSignal.throwIfAborted();
-                    await assertReplaceableOutput(plan.targetPath);
-                    extractionSignal.throwIfAborted();
-                    await rename(temporaryPath, plan.targetPath);
-                }
-                catch (error) {
-                    await rm(temporaryPath, { force: true });
-                    throw error;
+                    outputs.push({
+                        id: plan.entry.id,
+                        path: plan.targetPath,
+                        overwrite: options.overwrite === true,
+                    });
                 }
-            }
-            else {
-                await pipeline(this.createReadStream(plan.entry.id, {
-                    signal: extractionSignal,
-                    maxBytes: null,
-                }), limit, createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 }), { signal: extractionSignal });
-            }
-            filesExtracted++;
-            reportProgress();
-            options.onExtract?.({ entry: plan.entry, outputPath: plan.targetPath });
-        };
-        const runWorker = async () => {
-            while (!hasFailure) {
-                if (options.signal?.aborted) {
-                    stop(options.signal.reason);
-                    return;
-                }
-                const plan = filePlans[nextFileIndex++];
-                if (!plan) {
-                    return;
-                }
-                try {
-                    await extractFile(plan);
+                let onFileCompleted;
+                const onExtract = options.onExtract;
+                if (onExtract) {
+                    const plansById = new Map(group.map(plan => [plan.entry.id, plan]));
+                    onFileCompleted = (id) => {
+                        if (completionFailed || hasFailure) {
+                            return;
+                        }
+                        try {
+                            const plan = plansById.get(id);
+                            if (plan === undefined) {
+                                throw new ArchiveError('ERR_ARCHIVE_EXTRACT', 'Native folder extraction returned an unknown file completion');
+                            }
+                            extractionSignal.throwIfAborted();
+                            filesExtracted++;
+                            onExtract({
+                                entry: plan.entry,
+                                outputPath: plan.targetPath,
+                                percent: filesExtracted * 100 / filePlans.length,
+                            });
+                        }
+                        catch (error) {
+                            completionFailed = true;
+                            completionFailure = error;
+                            stop(error);
+                        }
+                    };
                 }
-                catch (error) {
-                    stop(error);
-                    return;
+                await this.extractEntriesToFiles(outputs, extractionSignal, onFileCompleted);
+                if (completionFailed) {
+                    throw completionFailure;
                 }
             }
+            catch (caughtError) {
+                throw completionFailed ? completionFailure : caughtError;
+            }
         };
         try {
             options.signal?.throwIfAborted();
-            const workers = Array.from({ length: Math.min(concurrency, filePlans.length) }, () => runWorker());
-            await Promise.all(workers);
-            if (hasFailure) {
+            const workers = fileGroups.map(group => extractGroup(group));
+            try {
+                await Promise.all(workers);
+            }
+            catch (error) {
+                stop(error);
+                await Promise.allSettled(workers);
                 throw failure;
             }
         }
@@ -706,8 +732,67 @@ class Archive {
             options.signal?.removeEventListener('abort', abortFromCaller);
         }
     }
-    async read(idOrPath, options) {
+    async read(idOrPathOrPaths, options) {
         this.assertOpen();
+        const maxUInt64 = (1n << 64n) - 1n;
+        const normalizeRange = (range) => {
+            const offset = this.toUnsignedBigInt(range.offset ?? 0, 'offset');
+            const length = this.toUnsignedBigInt(range.length, 'length');
+            if (offset > maxUInt64 || length > maxUInt64 - offset) {
+                throw new ArchiveError('ERR_INVALID_RANGE', 'Read range exceeds the native 64-bit offset limit');
+            }
+            return { offset, length };
+        };
+        if (options === undefined) {
+            if (!Array.isArray(idOrPathOrPaths)) {
+                throw new TypeError('Read options are required for an entry selector');
+            }
+            const requests = idOrPathOrPaths;
+            const normalized = await Promise.all(requests.map(async (request) => {
+                if (!request || typeof request !== 'object' || !('entry' in request)) {
+                    throw new TypeError('Batch read requests must include an entry selector');
+                }
+                const range = normalizeRange(request);
+                return {
+                    id: await this.resolveEntryId(request.entry),
+                    ...range,
+                };
+            }));
+            if (!normalized.length) {
+                return [];
+            }
+            try {
+                return await native.readMany(this.handle, normalized);
+            }
+            catch (cause) {
+                throw extractionError(cause);
+            }
+        }
+        const isBatch = Array.isArray(idOrPathOrPaths);
+        let selectors;
+        if (isBatch) {
+            selectors = idOrPathOrPaths;
+        }
+        else {
+            selectors = [idOrPathOrPaths];
+        }
+        const { offset, length } = normalizeRange(options);
+        if (isBatch) {
+            const ids = await Promise.all(selectors.map(selector => this.resolveEntryId(selector)));
+            const uniqueIds = [...new Set(ids)];
+            if (!uniqueIds.length) {
+                return [];
+            }
+            try {
+                const buffers = await native.readMany(this.handle, uniqueIds.map(id => ({ id, offset, length })));
+                const buffersById = new Map(uniqueIds.map((id, index) => [id, buffers[index]]));
+                return ids.map(id => buffersById.get(id));
+            }
+            catch (cause) {
+                throw extractionError(cause);
+            }
+        }
+        const idOrPath = selectors[0];
         let id;
         if (typeof idOrPath === 'number') {
             this.validateIds([idOrPath]);
@@ -716,12 +801,6 @@ class Archive {
         else {
             id = await this.resolveEntryId(idOrPath);
         }
-        const offset = this.toUnsignedBigInt(options.offset ?? 0, 'offset');
-        const length = this.toUnsignedBigInt(options.length, 'length');
-        const maxUInt64 = (1n << 64n) - 1n;
-        if (offset > maxUInt64 || length > maxUInt64 - offset) {
-            throw new ArchiveError('ERR_INVALID_RANGE', 'Read range exceeds the native 64-bit offset limit');
-        }
         try {
             return await native.read(this.handle, id, offset, length);
         }
@@ -729,6 +808,32 @@ class Archive {
             throw extractionError(cause);
         }
     }
+    async extractEntriesToFiles(outputs, signal, onFileCompleted) {
+        let task;
+        const cancelTask = () => {
+            if (task) {
+                native.cancelExtractToFiles(task.taskId);
+            }
+        };
+        try {
+            signal.throwIfAborted();
+            task = native.startExtractToFiles(this.handle, outputs, onFileCompleted);
+            signal.addEventListener('abort', cancelTask, { once: true });
+            if (signal.aborted) {
+                cancelTask();
+            }
+            return await task.promise;
+        }
+        catch (cause) {
+            if (signal.aborted) {
+                throw signal.reason ?? cause;
+            }
+            throw extractionError(cause);
+        }
+        finally {
+            signal.removeEventListener('abort', cancelTask);
+        }
+    }
     async close() {
         if (this.closed) {
             return;