@zip.js/zip.js 2.8.59 → 2.8.61

package/lib/core/zip-writer.js

@@ -56,17 +56,16 @@
  *   the insertion order of the `fileEntries` map. addFile() reserves each entry's slot synchronously in
  *   add() call order, before initializing the reader, so concurrent entries whose readers
  *   initialize at different speeds are still listed in call order.
- * - `fileEntry.lockFileEntry` chains every entry to the previous one to reach getFileEntry(); awaiting it
- *   serializes the physical writes when `keepOrder` is set. The physical layout therefore follows
- *   the order in which the readers finish initializing, not necessarily the central directory
- *   order; each entry records its own `offset`, so the archive stays consistent either way.
+ * - `fileEntry.lockFileEntry` chains every entry to the previous one; awaiting it serializes the
+ *   physical writes when `keepOrder` is set. addFile() claims the link in the same synchronous
+ *   prologue as the central directory slot, so the physical layout follows the add() call order
+ *   as well, whatever the readers do. The lock is released for every entry, including the ones
+ *   failing before they reach getFileEntry().
  * - `zipWriter.lockWriter`/`writerLocked` is the mutex over the writer; only the holder may write
  *   into it or read the position variables above.
- * - An entry writes directly into the writer (i.e. without being buffered) only when the writer
- *   is unlocked and no buffered entry is in flight (`bufferedWrites` == 0). This avoids a
- *   deadlock, it is not an optimization: an entry written directly acquires the writer lock
- *   before awaiting the lock of the previous entry, while a buffered predecessor needs the
- *   writer lock to be flushed.
+ * - Both write paths await the lock of the previous entry before requesting the writer lock.
+ *   Requesting it first would deadlock an entry written directly into the writer (i.e. without
+ *   being buffered) against a buffered predecessor, which needs that same lock to be flushed.
  * - `lastFileEntry` is the tail of the lock chain (the most recently added entry).
  *
  * Failures:
@@ -689,6 +688,13 @@ async function addFile(zipWriter, name, reader, options) {
 	const { comment } = metadataInfo;
 	const extraField = options[PROPERTY_NAME_EXTRA_FIELD];
 	zipWriter.fileEntries.set(name, UNDEFINED_VALUE);
+	const previousFileEntry = zipWriter.lastFileEntry;
+	const pendingFileEntry = {};
+	let releaseLockFileEntry;
+	if (metadataInfo.resolvedOptions.keepOrder) {
+		pendingFileEntry.lockFileEntry = new Promise(resolve => releaseLockFileEntry = resolve);
+	}
+	zipWriter.lastFileEntry = pendingFileEntry;
 	let fileEntry;
 	try {
 		const { resolvedOptions } = metadataInfo;
@@ -710,10 +716,21 @@ async function addFile(zipWriter, name, reader, options) {
 		const headerInfo = getHeaderInfo(options);
 		const dataDescriptorInfo = getDataDescriptorInfo(options);
 		const metadataSize = getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray);
-		fileEntry = await getFileEntry(zipWriter, name, reader, { headerInfo, dataDescriptorInfo, metadataSize }, options);
+		fileEntry = await getFileEntry(zipWriter, name, reader, {
+			headerInfo,
+			dataDescriptorInfo,
+			metadataSize,
+			fileEntry: pendingFileEntry,
+			previousFileEntry,
+			releaseLockFileEntry
+		}, options);
 	} catch (error) {
 		zipWriter.fileEntries.delete(name);
 		throw error;
+	} finally {
+		if (releaseLockFileEntry) {
+			releaseLockFileEntry(previousFileEntry && previousFileEntry.lockFileEntry);
+		}
 	}
 	Object.assign(fileEntry, {
 		name,
@@ -1101,7 +1118,6 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 	}
 	const usdz = writerOptions[OPTION_USDZ];
 	const files = new Map();
-	let layoutDependsOnWriteOrder = Boolean(usdz);
 	const initialOffset = writerOptions[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : writerOptions[OPTION_OFFSET];
 	let offset = initialOffset;
 	let minimumEntrySize = INFINITY_VALUE;
@@ -1147,9 +1163,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 		minimumEntrySize = Math.min(minimumEntrySize, entrySize);
 		offset += entrySize;
 	}
-	if (files.size && offset - minimumEntrySize >= MAX_32_BITS) {
-		layoutDependsOnWriteOrder = true;
-	}
+	const layoutDependsOnWriteOrder = files.size > 1 && (usdz || offset - minimumEntrySize >= MAX_32_BITS);
 	if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
 		throw new Error(ERR_UNDETERMINED_SIZE);
 	}
@@ -1177,27 +1191,23 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		signal
 	} = options;
 	const {
-		headerInfo
+		headerInfo,
+		fileEntry: pendingFileEntry,
+		previousFileEntry,
+		releaseLockFileEntry
 	} = entryInfo;
 	const usdz = zipWriter.options[OPTION_USDZ];
-	const previousFileEntry = zipWriter.lastFileEntry;
-	let fileEntry = {};
+	let fileEntry = pendingFileEntry;
 	let bufferedWrite;
 	let releaseLockWriter;
-	let releaseLockCurrentFileEntry;
 	let writingBufferedEntryData;
 	let writingEntryData;
 	let writerSizeBeforeEntry;
 	let flushedBufferedSize = 0;
 	let fileWriter;
+	const lockPreviousFileEntry = keepOrder && previousFileEntry ? previousFileEntry.lockFileEntry : UNDEFINED_VALUE;
 	fileEntries.set(name, fileEntry);
-	zipWriter.lastFileEntry = fileEntry;
 	try {
-		let lockPreviousFileEntry;
-		if (keepOrder) {
-			lockPreviousFileEntry = previousFileEntry && previousFileEntry.lockFileEntry;
-			requestLockCurrentFileEntry();
-		}
 		if (options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || (!dataDescriptor && !emptyEntry)) {
 			bufferedWrite = true;
 			zipWriter.bufferedWrites++;
@@ -1210,6 +1220,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await initStream(writer);
 		} else {
 			fileWriter = writer;
+			await lockPreviousFileEntry;
 			await requestLockWriter();
 		}
 		await initStream(fileWriter);
@@ -1222,7 +1233,6 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		}
 		const { localHeaderArray } = headerInfo;
 		if (!bufferedWrite) {
-			await lockPreviousFileEntry;
 			await skipDiskIfNeeded();
 		}
 		const diskNumberStart = getDiskNumber(writer);
@@ -1287,8 +1297,8 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		if (bufferedWrite) {
 			zipWriter.bufferedWrites--;
 		}
-		if (releaseLockCurrentFileEntry) {
-			releaseLockCurrentFileEntry();
+		if (releaseLockFileEntry) {
+			releaseLockFileEntry(lockPreviousFileEntry);
 		}
 		if (releaseLockWriter) {
 			releaseLockWriter();
@@ -1302,10 +1312,6 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		}
 	}
 
-	function requestLockCurrentFileEntry() {
-		fileEntry.lockFileEntry = new Promise(resolve => releaseLockCurrentFileEntry = resolve);
-	}
-
 	async function requestLockWriter() {
 		zipWriter.writerLocked = true;
 		const { lockWriter } = zipWriter;
@@ -1440,6 +1446,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		const workerOptions = {
 			options: {
 				codecType: CODEC_DEFLATE,
+				inputSize: size,
 				level,
 				rawPassword,
 				password,

package/lib/zip-core-base.js

@@ -71,10 +71,17 @@ export {
 export {
 	registerCodec,
 	unregisterCodec,
+	getRegisteredCodecs,
 	ERR_INVALID_CODEC_DEFINITION,
 	ERR_RESERVED_COMPRESSION_METHOD,
 	ERR_INVALID_CODEC_MODULE
 } from "./core/codec-registry.js";
+export {
+	getSupportedCompressionMethods
+} from "./core/compression-methods.js";
+export {
+	VERSION
+} from "./core/version.js";
 export {
 	createOPFSTempStream
 } from "./core/util/opfs-temp-stream.js";

package/lib/zip-fs-core.js

@@ -0,0 +1,32 @@
+/// <reference types="../index.d.ts" />
+
+/*
+ Copyright (c) 2025 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+export * from "./zip-core.js";
+export * from "./core/zip-fs.js";

package/package.json

@@ -3,7 +3,7 @@
   "description": "A JavaScript library to zip and unzip files in the browser, Deno and Node.js",
   "author": "Gildas Lormeau",
   "license": "BSD-3-Clause",
-  "version": "2.8.59",
+  "version": "2.8.61",
   "type": "module",
   "keywords": [
     "zip",
@@ -34,11 +34,12 @@
     "bun": ">=0.7.0"
   },
   "scripts": {
-    "version": "node ./sync-deno-version.js && git add deno.json",
+    "version": "node ./sync-versions.js && git add deno.json lib/core/version.js",
     "bump-patch": "npm version patch --no-git-tag-version && npm run bump-commit",
     "bump-minor": "npm version minor --no-git-tag-version && npm run bump-commit",
     "bump-major": "npm version major --no-git-tag-version && npm run bump-commit",
-    "bump-commit": "git commit -m \"bump up version\" package.json package-lock.json deno.json",
+    "bump-commit": "npm run build && git commit -m \"bump up version\" package.json package-lock.json deno.json lib/core/version.js dist index.cjs index-native.cjs index.min.js index-native.min.js lib/core/web-worker-inline-wasm.js lib/core/web-worker-inline-native.js",
+    "release": "sh ./release.sh",
     "lint": "npx eslint . && deno lint",
     "test": "npm run test-node && npm run test-deno && npm run test-bun && npm run test-node-dist && npm run test-deno-dist && npm run test-bun-dist && npm run test-web-streams-polyfill && npm run test-types && npm run test-api-symmetry && npm run test-api-shape && npm run test-api-mangling",
     "test-browsers": "npm run test-chrome && npm run test-firefox && npm run test-safari",

package/release.sh

@@ -0,0 +1,47 @@
+#!/bin/sh
+# Creates the GitHub release for the version declared in package.json, which triggers the publish
+# workflow. It only encodes the checks a release must pass anyway: the released commit is the pushed
+# master head, its tests concluded green (the publish gate would otherwise fail after the release
+# exists, and recovering means deleting the release and the tag), and the tag targets the branch
+# because the API rejects abbreviated commit SHAs as a target.
+set -e
+
+notes_file=$1
+if [ -z "$notes_file" ]; then
+	echo "usage: npm run release -- <notes-file>" >&2
+	exit 1
+fi
+if [ ! -f "$notes_file" ]; then
+	echo "notes file not found: $notes_file" >&2
+	exit 1
+fi
+version=$(node -p "require('./package.json').version")
+tag="v$version"
+if gh release view "$tag" >/dev/null 2>&1; then
+	echo "release $tag already exists" >&2
+	exit 1
+fi
+if [ -n "$(git status --porcelain)" ]; then
+	echo "the working tree is not clean" >&2
+	exit 1
+fi
+git fetch origin master
+sha=$(git rev-parse HEAD)
+if [ "$sha" != "$(git rev-parse origin/master)" ]; then
+	echo "HEAD is not origin/master, push the bump commit first" >&2
+	exit 1
+fi
+run=$(gh api "repos/{owner}/{repo}/actions/workflows/test.yml/runs?head_sha=$sha&per_page=1" \
+	--jq 'if (.workflow_runs | length) == 0 then "none none none" else (.workflow_runs[0] | "\(.status) \(.conclusion) \(.html_url)") end')
+run_status=$(echo "$run" | cut -d " " -f 1)
+conclusion=$(echo "$run" | cut -d " " -f 2)
+url=$(echo "$run" | cut -d " " -f 3)
+if [ "$run_status" = "none" ]; then
+	echo "no test run found for $sha yet, wait for it and run this again" >&2
+	exit 1
+fi
+if [ "$run_status" != "completed" ] || [ "$conclusion" != "success" ]; then
+	echo "the tests of $sha concluded $run_status/$conclusion, only a green commit can be released: $url" >&2
+	exit 1
+fi
+gh release create "$tag" --target master --notes-file "$notes_file"

package/sync-versions.js

@@ -0,0 +1,26 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const JSON_VERSION_REGEXP = /("version"\s*:\s*")[^"]*(")/;
+const LIB_VERSION_REGEXP = /(const VERSION = ")[^"]*(")/;
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_PATH = path.resolve(__dirname, "package.json");
+const DENO_PATH = path.resolve(__dirname, "deno.json");
+const LIB_VERSION_PATH = path.resolve(__dirname, "lib", "core", "version.js");
+
+const { version } = JSON.parse(fs.readFileSync(PACKAGE_PATH, "utf8"));
+syncVersion(DENO_PATH, JSON_VERSION_REGEXP);
+syncVersion(LIB_VERSION_PATH, LIB_VERSION_REGEXP);
+
+function syncVersion(filePath, versionRegExp) {
+	const source = fs.readFileSync(filePath, "utf8");
+	if (!versionRegExp.test(source)) {
+		throw new Error("no version found in " + path.basename(filePath));
+	}
+	const syncedSource = source.replace(versionRegExp, "$1" + version + "$2");
+	if (syncedSource != source) {
+		fs.writeFileSync(filePath, syncedSource);
+	}
+}