@zip.js/zip.js 2.5.21 → 2.5.24

package/lib/core/zip-writer.js

@@ -68,7 +68,9 @@ import {
 	runWorker
 } from "./codec-pool.js";
 import encodeText from "./util/encode-text.js";
-import { BlobWriter } from "./io.js";
+import {
+	BlobWriter
+} from "./io.js";
 import Entry from "./zip-entry.js";
 
 const ERR_DUPLICATED_NAME = "File already exists";
@@ -103,17 +105,22 @@ class ZipWriter {
 
 	async add(name = "", reader, options = {}) {
 		const zipWriter = this;
-		if (workers < zipWriter.config.maxWorkers) {
+		const {
+			pendingAddFileCalls,
+			pendingEntries,
+			config
+		} = zipWriter;
+		if (workers < config.maxWorkers) {
 			workers++;
 			let promiseAddFile;
 			try {
 				promiseAddFile = addFile(zipWriter, name, reader, options);
-				this.pendingAddFileCalls.add(promiseAddFile);
+				pendingAddFileCalls.add(promiseAddFile);
 				return await promiseAddFile;
 			} finally {
-				this.pendingAddFileCalls.delete(promiseAddFile);
+				pendingAddFileCalls.delete(promiseAddFile);
 				workers--;
-				const pendingEntry = zipWriter.pendingEntries.shift();
+				const pendingEntry = pendingEntries.shift();
 				if (pendingEntry) {
 					zipWriter.add(pendingEntry.name, pendingEntry.reader, pendingEntry.options)
 						.then(pendingEntry.resolve)
@@ -121,7 +128,7 @@ class ZipWriter {
 				}
 			}
 		} else {
-			return new Promise((resolve, reject) => zipWriter.pendingEntries.push({ name, reader, options, resolve, reject }));
+			return new Promise((resolve, reject) => pendingEntries.push({ name, reader, options, resolve, reject }));
 		}
 	}
 
@@ -294,22 +301,31 @@ async function addFile(zipWriter, name, reader, options) {
 }
 
 async function getFileEntry(zipWriter, name, reader, options) {
-	const { files, writer } = zipWriter;
+	const {
+		files,
+		writer
+	} = zipWriter;
+	const {
+		keepOrder,
+		dataDescriptor,
+		zipCrypto,
+		signal
+	} = options;
 	const previousFileEntry = Array.from(files.values()).pop();
 	let fileEntry = {};
 	let bufferedWrite;
 	let releaseLockWriter;
-	let resolveLockCurrentFileEntry;
-	let writingBufferedData;
+	let releaseLockCurrentFileEntry;
+	let bufferedDataWritten;
+	let fileWriter;
 	files.set(name, fileEntry);
 	try {
 		let lockPreviousFileEntry;
-		let fileWriter;
-		if (options.keepOrder) {
+		if (keepOrder) {
 			lockPreviousFileEntry = previousFileEntry && previousFileEntry.lock;
+			requestLockCurrentFileEntry();
 		}
-		fileEntry.lock = new Promise(resolve => resolveLockCurrentFileEntry = resolve);
-		if (options.bufferedWrite || zipWriter.lockWriter || !options.dataDescriptor) {
+		if (options.bufferedWrite || zipWriter.lockWriter || !dataDescriptor) {
 			fileWriter = new BlobWriter();
 			fileWriter.init();
 			bufferedWrite = true;
@@ -320,20 +336,20 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			}
 			fileWriter = writer;
 		}
-		fileEntry = await createFileEntry(reader, fileWriter.writable, zipWriter.config, options);
+		fileEntry = await createFileEntry(reader, fileEntry, fileWriter.writable, zipWriter.config, options);
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
 		if (bufferedWrite) {
 			let blob = fileWriter.getData();
 			await lockPreviousFileEntry;
-			await lockWriter();
-			writingBufferedData = true;
+			await requestLockWriter();
+			bufferedDataWritten = true;
 			const { writable } = writer;
-			if (!options.dataDescriptor) {
+			if (!dataDescriptor) {
 				const headerLength = 26;
 				const arrayBuffer = await sliceAsArrayBuffer(blob, 0, headerLength);
 				const arrayBufferView = new DataView(arrayBuffer);
-				if (!fileEntry.encrypted || options.zipCrypto) {
+				if (!fileEntry.encrypted || zipCrypto) {
 					setUint32(arrayBufferView, 14, fileEntry.signature);
 				}
 				if (fileEntry.zip64) {
@@ -346,8 +362,8 @@ async function getFileEntry(zipWriter, name, reader, options) {
 				await writeUint8Array(writable, new Uint8Array(arrayBuffer));
 				blob = blob.slice(headerLength);
 			}
-			await blob.stream().pipeTo(writable, { preventClose: true });
-			writingBufferedData = false;
+			await blob.stream().pipeTo(writable, { preventClose: true, signal });
+			bufferedDataWritten = false;
 		}
 		fileEntry.offset = zipWriter.offset;
 		if (fileEntry.zip64) {
@@ -359,32 +375,37 @@ async function getFileEntry(zipWriter, name, reader, options) {
 		zipWriter.offset += fileEntry.length;
 		return fileEntry;
 	} catch (error) {
-		if ((bufferedWrite && writingBufferedData) || (!bufferedWrite && fileEntry.dataWritten)) {
+		if ((bufferedWrite && bufferedDataWritten) || (!bufferedWrite && fileEntry.dataWritten)) {
 			error.corruptedEntry = zipWriter.hasCorruptedEntries = true;
-			if (fileEntry.uncompressedSize) {
-				zipWriter.offset += fileEntry.uncompressedSize;
-			}
+			zipWriter.offset += fileWriter.size;
 		}
 		files.delete(name);
 		throw error;
 	} finally {
-		resolveLockCurrentFileEntry();
+		if (releaseLockCurrentFileEntry) {
+			releaseLockCurrentFileEntry();
+		}
 		if (releaseLockWriter) {
 			releaseLockWriter();
 		}
 	}
 
-	async function lockWriter() {
-		if (zipWriter.lockWriter) {
-			await zipWriter.lockWriter.then(() => delete zipWriter.lockWriter);
-			await lockWriter();
+	function requestLockCurrentFileEntry() {
+		fileEntry.lock = new Promise(resolve => releaseLockCurrentFileEntry = resolve);
+	}
+
+	async function requestLockWriter() {
+		const { lockWriter } = zipWriter;
+		if (lockWriter) {
+			await lockWriter.then(() => delete zipWriter.lockWriter);
+			return requestLockWriter();
 		} else {
 			zipWriter.lockWriter = new Promise(resolve => releaseLockWriter = resolve);
 		}
 	}
 }
 
-async function createFileEntry(reader, writable, config, options) {
+async function createFileEntry(reader, pendingFileEntry, writable, config, options) {
 	const {
 		rawFilename,
 		lastAccessDate,
@@ -519,7 +540,7 @@ async function createFileEntry(reader, writable, config, options) {
 	const rawLastModDate = dateArray[0];
 	setUint32(headerView, 6, rawLastModDate);
 	setUint16(headerView, 22, rawFilename.length);
-	const extraFieldLength = rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length + fileEntry.rawExtraField.length;
+	const extraFieldLength = rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length + rawExtraField.length;
 	setUint16(headerView, 24, extraFieldLength);
 	const localHeaderArray = new Uint8Array(30 + rawFilename.length + extraFieldLength);
 	const localHeaderView = getDataView(localHeaderArray);
@@ -529,16 +550,16 @@ async function createFileEntry(reader, writable, config, options) {
 	arraySet(localHeaderArray, rawExtraFieldAES, 30 + rawFilename.length);
 	arraySet(localHeaderArray, rawExtraFieldExtendedTimestamp, 30 + rawFilename.length + rawExtraFieldAES.length);
 	arraySet(localHeaderArray, rawExtraFieldNTFS, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length);
-	arraySet(localHeaderArray, fileEntry.rawExtraField, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length);
+	arraySet(localHeaderArray, rawExtraField, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length);
 	let result;
 	let compressedSize = 0;
 	if (reader) {
+		reader.chunkSize = getChunkSize(config);
 		await writeUint8Array(writable, localHeaderArray);
-		fileEntry.dataWritten = true;
+		fileEntry.dataWritten = pendingFileEntry.dataWritten = true;
 		const size = () => reader.size;
 		const readable = reader.readable;
 		readable.size = size;
-		readable.chunkSize = getChunkSize(config);
 		const workerOptions = {
 			options: {
 				codecType: CODEC_DEFLATE,
@@ -562,7 +583,7 @@ async function createFileEntry(reader, writable, config, options) {
 		compressedSize = result.length;
 	} else {
 		await writeUint8Array(writable, localHeaderArray);
-		fileEntry.dataWritten = true;
+		fileEntry.dataWritten = pendingFileEntry.dataWritten = true;
 	}
 	let dataDescriptorArray = new Uint8Array();
 	let dataDescriptorView, dataDescriptorOffset = 0;
@@ -608,7 +629,15 @@ async function createFileEntry(reader, writable, config, options) {
 		await writeUint8Array(writable, dataDescriptorArray);
 	}
 	const length = localHeaderArray.length + compressedSize + dataDescriptorArray.length;
-	Object.assign(fileEntry, { compressedSize, lastModDate, rawLastModDate, creationDate, lastAccessDate, encrypted, length });
+	Object.assign(fileEntry, {
+		compressedSize,
+		lastModDate,
+		rawLastModDate,
+		creationDate,
+		lastAccessDate,
+		encrypted,
+		length
+	});
 	return fileEntry;
 }
 

package/package.json

@@ -3,7 +3,7 @@
     "description": "A JavaScript library to zip and unzip files in the browser and Deno",
     "author": "Gildas Lormeau",
     "license": "BSD-3-Clause",
-    "version": "2.5.21",
+    "version": "2.5.24",
     "type": "module",
     "keywords": [
         "zip",