7zip-native 0.0.1 → 0.0.6

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { existsSync, createWriteStream } from 'node:fs';
-import { lstat, mkdir } from 'node:fs/promises';
+import { rename, 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, relative, sep } from 'node:path';
@@ -121,6 +122,19 @@ async function ensureDirectory(directoryPath) {
         throw new ArchiveError('ERR_ARCHIVE_PATH', `Destination path is not a real directory: ${directoryPath}`);
     }
 }
+async function assertReplaceableOutput(filePath) {
+    try {
+        const details = await lstat(filePath);
+        if (!details.isFile()) {
+            throw new ArchiveError('ERR_ARCHIVE_PATH', `Cannot replace a non-file extraction target: ${filePath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ArchiveError || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
 async function ensureExtractionRoot(root) {
     try {
         const details = await lstat(root);
@@ -164,6 +178,7 @@ class NativeArchiveReadable extends Readable {
     maxBytes;
     streamId;
     outputBytes = 0n;
+    starting = false;
     constructor(start, resumeNative, cancel, options, maxBytes) {
         super({ highWaterMark: options.highWaterMark, signal: options.signal });
         this.start = start;
@@ -172,38 +187,63 @@ class NativeArchiveReadable extends Readable {
         this.maxBytes = maxBytes;
     }
     _read() {
+        if (this.streamId !== undefined) {
+            try {
+                this.resumeNative(this.streamId);
+            }
+            catch (cause) {
+                this.destroy(extractionError(cause));
+            }
+            return;
+        }
+        if (this.starting) {
+            return;
+        }
+        this.starting = true;
         try {
-            if (this.streamId === undefined) {
-                this.streamId = this.start((chunk, error, done) => {
-                    if (this.destroyed) {
+            Promise.resolve(this.start((chunk, error, done) => {
+                if (this.destroyed) {
+                    return;
+                }
+                if (error) {
+                    this.destroy(extractionError(error));
+                }
+                else if (done) {
+                    this.push(null);
+                }
+                else if (chunk) {
+                    if (this.maxBytes !== null
+                        && this.outputBytes + BigInt(chunk.length) > this.maxBytes) {
+                        this.destroy(new ArchiveError('ERR_RESOURCE_LIMIT', `Stream output exceeds the ${this.maxBytes}-byte limit`));
                         return;
                     }
-                    if (error) {
-                        this.destroy(extractionError(error));
-                    }
-                    else if (done) {
-                        this.push(null);
-                    }
-                    else if (chunk) {
-                        if (this.maxBytes !== null
-                            && this.outputBytes + BigInt(chunk.length) > this.maxBytes) {
-                            this.destroy(new ArchiveError('ERR_RESOURCE_LIMIT', `Stream output exceeds the ${this.maxBytes}-byte limit`));
-                            return;
-                        }
-                        this.outputBytes += BigInt(chunk.length);
-                        this.push(chunk);
+                    this.outputBytes += BigInt(chunk.length);
+                    this.push(chunk);
+                }
+                else {
+                    this.destroy(new ArchiveError('ERR_ARCHIVE_EXTRACT', 'Native stream returned an empty chunk notification'));
+                }
+            })).then((streamId) => {
+                this.streamId = streamId;
+                this.starting = false;
+                try {
+                    if (this.destroyed) {
+                        this.cancel(streamId);
                     }
                     else {
-                        this.destroy(new ArchiveError('ERR_ARCHIVE_EXTRACT', 'Native stream returned an empty chunk notification'));
+                        this.resumeNative(streamId);
                     }
-                });
-                this.resumeNative(this.streamId);
-            }
-            else {
-                this.resumeNative(this.streamId);
-            }
+                }
+                catch (cause) {
+                    this.destroy(extractionError(cause));
+                }
+            }, (cause) => {
+                this.starting = false;
+                this.destroy(extractionError(cause));
+            });
         }
         catch (cause) {
+            this.starting = false;
             this.destroy(extractionError(cause));
         }
     }
@@ -269,21 +309,41 @@ class Archive {
         }
         return (await this.entries()).find(entry => typeof idOrPath === 'number' ? entry.id === idOrPath : entry.path === idOrPath);
     }
-    async extract(idOrIds) {
+    async extract(idOrPathOrPaths) {
         this.assertOpen();
-        const ids = Array.isArray(idOrIds) ? [...idOrIds] : [idOrIds];
-        this.validateIds(ids);
+        const isBatch = Array.isArray(idOrPathOrPaths);
+        let selectors;
+        if (isBatch) {
+            selectors = idOrPathOrPaths;
+        }
+        else {
+            selectors = [idOrPathOrPaths];
+        }
+        const numericIds = selectors.filter((selector) => typeof selector === 'number');
+        let ids;
+        if (numericIds.length === selectors.length) {
+            this.validateIds(numericIds);
+            ids = numericIds;
+        }
+        else {
+            ids = await this.resolveEntryIds(selectors);
+        }
         try {
             const buffers = await native.extract(this.handle, ids);
-            return Array.isArray(idOrIds) ? buffers : buffers[0];
+            return isBatch ? buffers : buffers[0];
         }
         catch (cause) {
             throw extractionError(cause);
         }
     }
-    createReadStream(id, options = {}) {
+    createReadStream(idOrPath, options = {}) {
         this.assertOpen();
-        this.validateIds([id]);
+        if (typeof idOrPath === 'number') {
+            this.validateIds([idOrPath]);
+        }
+        else if (typeof idOrPath !== 'string') {
+            throw new TypeError('Entry selector must be an ID or archive path');
+        }
         if (!options || typeof options !== 'object') {
             throw new TypeError('Stream options must be an object');
         }
@@ -295,13 +355,18 @@ class Archive {
         }
         options.signal?.throwIfAborted();
         const maxBytes = normalizeMaxBytes(options.maxBytes, 'maxBytes');
-        return new NativeArchiveReadable(callback => native.startStream(this.handle, id, callback), streamId => native.resumeStream(streamId), streamId => native.cancelStream(streamId), options, maxBytes);
+        return new NativeArchiveReadable((callback) => {
+            if (typeof idOrPath === 'number') {
+                return native.startStream(this.handle, idOrPath, callback);
+            }
+            return this.resolveEntryId(idOrPath).then(id => native.startStream(this.handle, id, callback));
+        }, streamId => native.resumeStream(streamId), streamId => native.cancelStream(streamId), options, maxBytes);
     }
-    async extractToStream(id, destination, options = {}) {
+    async extractToStream(idOrPath, destination, options = {}) {
         if (!destination || typeof destination.write !== 'function') {
             throw new TypeError('Destination must be a writable stream');
         }
-        await pipeline(this.createReadStream(id, options), destination, { signal: options.signal });
+        await pipeline(this.createReadStream(idOrPath, options), destination, { signal: options.signal });
     }
     async extractToFolder(destination, options = {}) {
         this.assertOpen();
@@ -311,10 +376,19 @@ class Archive {
         if (!options || typeof options !== 'object') {
             throw new TypeError('Folder extraction options must be an object');
         }
+        if (options.overwrite !== undefined && typeof options.overwrite !== 'boolean') {
+            throw new TypeError('Folder extraction overwrite option must be a boolean');
+        }
+        if (options.onProgress !== undefined && typeof options.onProgress !== 'function') {
+            throw new TypeError('Folder extraction onProgress option must be a function');
+        }
         options.signal?.throwIfAborted();
         const maxBytes = normalizeMaxBytes(options.maxBytes, 'maxBytes');
         const entries = await this.entries();
         let selectedEntries = entries;
+        if (options.ids !== undefined && options.paths !== undefined) {
+            throw new TypeError('Specify either folder extraction IDs or paths, not both');
+        }
         if (options.ids !== undefined) {
             if (!Array.isArray(options.ids)) {
                 throw new TypeError('Folder extraction IDs must be an array');
@@ -329,6 +403,21 @@ class Archive {
                 return entry;
             });
         }
+        else if (options.paths !== undefined) {
+            if (!Array.isArray(options.paths)
+                || options.paths.some(entryPath => typeof entryPath !== 'string')) {
+                throw new TypeError('Folder extraction paths must be an array of strings');
+            }
+            const ids = await this.resolveEntryIds(options.paths);
+            const entriesById = new Map(entries.map(entry => [entry.id, entry]));
+            selectedEntries = ids.map((id) => {
+                const entry = entriesById.get(id);
+                if (!entry) {
+                    throw new ArchiveError('ERR_INVALID_ENTRY', `Entry ID ${id} is out of range`);
+                }
+                return entry;
+            });
+        }
         const root = resolve(destination);
         const plans = makeOutputPlans(root, selectedEntries);
         const expectedBytes = selectedEntries.reduce((total, entry) => total + (entry.isDirectory ? 0n : entry.size), 0n);
@@ -338,6 +427,26 @@ class Archive {
         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) {
@@ -345,7 +454,6 @@ class Archive {
                 continue;
             }
             await ensureOutputParents(root, plan.targetPath);
-            const output = createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 });
             const limit = new Transform({
                 transform(chunk, _encoding, callback) {
                     const size = BigInt(chunk.length);
@@ -354,18 +462,52 @@ class Archive {
                         return;
                     }
                     extractedBytes += size;
+                    try {
+                        reportProgress();
+                    }
+                    catch (error) {
+                        callback(error instanceof Error ? error : new Error(String(error)));
+                        return;
+                    }
                     callback(null, chunk);
                 },
             });
-            await pipeline(this.createReadStream(plan.entry.id, {
-                signal: options.signal,
-                maxBytes: null,
-            }), limit, output, { signal: options.signal });
+            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: options.signal,
+                        maxBytes: null,
+                    }), limit, createWriteStream(temporaryPath, { flags: 'wx', mode: 0o600 }), { signal: options.signal });
+                    await assertReplaceableOutput(plan.targetPath);
+                    await rename(temporaryPath, plan.targetPath);
+                }
+                catch (error) {
+                    await rm(temporaryPath, { force: true });
+                    throw error;
+                }
+            }
+            else {
+                await pipeline(this.createReadStream(plan.entry.id, {
+                    signal: options.signal,
+                    maxBytes: null,
+                }), limit, createWriteStream(plan.targetPath, { flags: 'wx', mode: 0o600 }), { signal: options.signal });
+            }
+            filesExtracted++;
+            reportProgress();
         }
     }
-    async read(id, options) {
+    async read(idOrPath, options) {
         this.assertOpen();
-        this.validateIds([id]);
+        let id;
+        if (typeof idOrPath === 'number') {
+            this.validateIds([idOrPath]);
+            id = idOrPath;
+        }
+        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;
@@ -396,6 +538,25 @@ class Archive {
             throw new ArchiveError('ERR_INVALID_ENTRY', 'Entry IDs must be unique non-negative safe integers');
         }
     }
+    async resolveEntryId(selector) {
+        if (typeof selector === 'number') {
+            this.validateIds([selector]);
+            return selector;
+        }
+        if (typeof selector !== 'string') {
+            throw new TypeError('Entry selector must be an ID or archive path');
+        }
+        const entry = await this.getEntry(selector);
+        if (!entry) {
+            throw new ArchiveError('ERR_INVALID_ENTRY', `Archive entry "${selector}" was not found`);
+        }
+        return entry.id;
+    }
+    async resolveEntryIds(selectors) {
+        const ids = await Promise.all(selectors.map(selector => this.resolveEntryId(selector)));
+        this.validateIds(ids);
+        return ids;
+    }
     toUnsignedBigInt(value, label) {
         if (typeof value === 'bigint') {
             if (value < 0n) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "7zip-native",
-	"version": "0.0.1",
+	"version": "0.0.6",
 	"description": "Native 7zip bindings for Node.js",
 	"main": "./dist/index.cjs",
 	"type": "module",
@@ -30,6 +30,7 @@
 		"dist/",
 		"prebuilds/",
 		"native/",
+		"scripts/",
 		"vendor/7zip/",
 		"binding.gyp",
 		"README.md",
@@ -48,6 +49,7 @@
 		"url": "https://github.com/sponsors/ollm"
 	},
 	"scripts": {
+		"install": "node scripts/verify-prebuild.mjs",
 		"prepare": "npm run build && node scripts/clean-upstream-build.mjs",
 		"build": "npm run build:native && npm run eslint && npx rollup -c && npm run typecheck",
 		"build:native": "node scripts/build-native.mjs",

package/scripts/build-native.mjs

@@ -0,0 +1,119 @@
+import {spawn} from 'node:child_process';
+import { copyFile, mkdir, rm } from 'node:fs/promises';
+import {createRequire} from 'node:module';
+import {availableParallelism} from 'node:os';
+import { join, resolve } from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const root = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const bundleDirectory = join(root, 'vendor', '7zip', 'CPP', '7zip', 'Bundles', 'Format7zF');
+const releaseDirectory = join(root, 'build', 'Release');
+const targetArch = process.env.BUILD_ARCH || process.arch;
+const target = `${process.platform}-${targetArch}`;
+const engineName = process.platform === 'win32'
+	? '7z.dll'
+	: process.platform === 'darwin' ? 'lib7z.dylib' : '7z.so';
+const require = createRequire(import.meta.url);
+
+function run(command, args, cwd, env = process.env)
+{
+	return new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(command, args, {cwd, env, stdio: 'inherit'});
+		child.once('error', rejectPromise);
+		child.once('close', (code, signal) => {
+			if(code === 0)
+			{
+				resolvePromise();
+			}
+			else
+			{
+				rejectPromise(new Error(`${command} exited with ${signal ?? code}`));
+			}
+		});
+	});
+}
+
+if(process.platform === 'win32')
+{
+	const upstreamArch = targetArch === 'ia32' ? 'x86' : targetArch;
+	await run('nmake', ['/f', 'makefile', `PLATFORM=${upstreamArch}`], bundleDirectory);
+}
+else
+{
+	const args = [
+		'-C',
+		bundleDirectory,
+		'-f',
+		'makefile.gcc',
+		`-j${process.env.BUILD_JOBS ?? Math.min(availableParallelism(), 2)}`,
+	];
+	const buildEnv = {...process.env};
+	if(targetArch === 'ia32')
+	{
+		args.push('MY_ARCH=-m32', 'CC=gcc', 'CXX=g++');
+		buildEnv.CXXFLAGS = `${buildEnv.CXXFLAGS ?? ''} -m32`.trim();
+		buildEnv.LDFLAGS = `${buildEnv.LDFLAGS ?? ''} -m32`.trim();
+	}
+	else if(targetArch === 'arm')
+	{
+		const compilerPrefix = 'arm-linux-gnueabihf-';
+		args.push(
+			`CC=${compilerPrefix}gcc`,
+			`CXX=${compilerPrefix}g++`,
+			'MY_ARCH=-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard',
+		);
+		buildEnv.CC = `${compilerPrefix}gcc`;
+		buildEnv.CXX = `${compilerPrefix}g++`;
+		buildEnv.CXXFLAGS = `${buildEnv.CXXFLAGS ?? ''} -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard`.trim();
+		buildEnv.LDFLAGS = `${buildEnv.LDFLAGS ?? ''} -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard`.trim();
+	}
+	if(process.platform === 'darwin')
+	{
+		args.push(
+			'LIB2=-lpthread',
+			'PROG=lib7z',
+			'SHARED_EXT=.dylib',
+			'LDFLAGS=-shared -fPIC -Wl,-install_name,@rpath/lib7z.dylib',
+		);
+	}
+	await run('make', args, root, buildEnv);
+}
+
+const upstreamEnginePath = process.platform === 'win32'
+	? join(bundleDirectory, targetArch === 'ia32' ? 'x86' : targetArch, engineName)
+	: join(bundleDirectory, '_o', engineName);
+const nodeGypArgs = [
+	require.resolve('node-gyp/bin/node-gyp.js'),
+	'rebuild',
+];
+const nodeGypEnv = {...process.env};
+if(targetArch !== process.arch)
+{
+	nodeGypArgs.push(`--arch=${targetArch}`);
+	if(targetArch === 'ia32')
+	{
+		nodeGypEnv.CC = 'gcc';
+		nodeGypEnv.CXX = 'g++';
+		nodeGypEnv.CXXFLAGS = `${nodeGypEnv.CXXFLAGS ?? ''} -m32`.trim();
+		nodeGypEnv.LDFLAGS = `${nodeGypEnv.LDFLAGS ?? ''} -m32`.trim();
+	}
+	else if(targetArch === 'arm')
+	{
+		nodeGypEnv.CC = 'arm-linux-gnueabihf-gcc';
+		nodeGypEnv.CXX = 'arm-linux-gnueabihf-g++';
+		nodeGypEnv.CXXFLAGS = `${nodeGypEnv.CXXFLAGS ?? ''} -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard`.trim();
+		nodeGypEnv.LDFLAGS = `${nodeGypEnv.LDFLAGS ?? ''} -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard`.trim();
+	}
+}
+await run(process.execPath, nodeGypArgs, root, nodeGypEnv);
+
+await mkdir(releaseDirectory, {recursive: true});
+const releaseEnginePath = join(releaseDirectory, engineName);
+await copyFile(upstreamEnginePath, releaseEnginePath);
+const prebuildDirectory = join(root, 'prebuilds', target);
+await rm(prebuildDirectory, {recursive: true, force: true});
+await mkdir(prebuildDirectory, {recursive: true});
+await Promise.all([
+	copyFile(join(releaseDirectory, '7zip_native.node'), join(prebuildDirectory, '7zip_native.node')),
+	copyFile(releaseEnginePath, join(prebuildDirectory, engineName)),
+]);

package/scripts/clean-upstream-build.mjs

@@ -0,0 +1,9 @@
+import {rm} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+
+const upstreamBuildDirectory = new URL(
+	'../vendor/7zip/CPP/7zip/Bundles/Format7zF/_o/',
+	import.meta.url,
+);
+
+await rm(fileURLToPath(upstreamBuildDirectory), {recursive: true, force: true});

package/scripts/verify-prebuild.mjs

@@ -0,0 +1,29 @@
+import {existsSync} from 'node:fs';
+import {dirname, join} from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const packageDirectory = dirname(fileURLToPath(import.meta.url));
+const target = `${process.platform}-${process.arch}`;
+const engineName = process.platform === 'win32'
+	? '7z.dll'
+	: process.platform === 'darwin' ? 'lib7z.dylib' : '7z.so';
+const runtimeDirectories = [
+	join(packageDirectory, `../prebuilds/${target}`),
+	join(packageDirectory, '../build/Release'),
+];
+
+if(runtimeDirectories.some(directory =>
+	existsSync(join(directory, '7zip_native.node')) && existsSync(join(directory, engineName))))
+{
+	process.exit(0);
+}
+
+if(existsSync(join(packageDirectory, '../.git')))
+{
+	process.exit(0);
+}
+
+throw new Error(
+	`No prebuilt 7zip-native binaries are available for ${target}. `
+	+ 'Check the supported platforms in the package README.',
+);