@zip.js/zip.js 2.6.18 → 2.6.21

package/lib/core/zip-writer.js

@@ -93,14 +93,17 @@ const pendingEntries = [];
 class ZipWriter {
 
 	constructor(writer, options = {}) {
+		if (writer.writable.size == undefined) {
+			writer.writable.size = 0;
+		}
 		Object.assign(this, {
 			writer,
 			options,
 			config: getConfiguration(),
 			files: new Map(),
 			filenames: new Set(),
-			offset: writer.size || 0,
-			pendingCompressedSize: 0,
+			offset: writer.writable.size,
+			pendingEntriesSize: 0,
 			pendingAddFileCalls: new Set()
 		});
 	}
@@ -225,6 +228,7 @@ async function addFile(zipWriter, name, reader, options) {
 		extendedTimestamp = true;
 	}
 	let maximumCompressedSize = 0;
+	let maximumEntrySize = 0;
 	let keepOrder = getOptionValue(zipWriter, options, "keepOrder");
 	if (keepOrder === undefined) {
 		keepOrder = true;
@@ -246,7 +250,7 @@ async function addFile(zipWriter, name, reader, options) {
 		maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 	}
 	let zip64 = options.zip64 || zipWriter.options.zip64 || false;
-	if (zipWriter.offset + zipWriter.pendingCompressedSize >= MAX_32_BITS ||
+	if (zipWriter.offset + zipWriter.pendingEntriesSize >= MAX_32_BITS ||
 		uncompressedSize >= MAX_32_BITS ||
 		maximumCompressedSize >= MAX_32_BITS) {
 		if (options.zip64 === false || zipWriter.options.zip64 === false || !keepOrder) {
@@ -255,8 +259,6 @@ async function addFile(zipWriter, name, reader, options) {
 			zip64 = true;
 		}
 	}
-	zipWriter.pendingCompressedSize += maximumCompressedSize;
-	await Promise.resolve();
 	const level = getOptionValue(zipWriter, options, "level");
 	const useWebWorkers = getOptionValue(zipWriter, options, "useWebWorkers");
 	const bufferedWrite = getOptionValue(zipWriter, options, "bufferedWrite");
@@ -270,7 +272,7 @@ async function addFile(zipWriter, name, reader, options) {
 	if (dataDescriptor && dataDescriptorSignature === undefined) {
 		dataDescriptorSignature = false;
 	}
-	const fileEntry = await getFileEntry(zipWriter, name, reader, Object.assign({}, options, {
+	options = Object.assign({}, options, {
 		rawFilename,
 		rawComment,
 		version,
@@ -295,15 +297,20 @@ async function addFile(zipWriter, name, reader, options) {
 		internalFileAttribute,
 		externalFileAttribute,
 		useCompressionStream
-	}));
-	if (maximumCompressedSize) {
-		zipWriter.pendingCompressedSize -= maximumCompressedSize;
+	});
+	const localHeaderInfo = getLocalHeaderInfo(options);
+	const dataDescriptorInfo = getDataDescriptorInfo(options);
+	maximumEntrySize = localHeaderInfo.localHeaderArray.length + maximumCompressedSize + dataDescriptorInfo.dataDescriptorArray.length;
+	zipWriter.pendingEntriesSize += maximumEntrySize;
+	const fileEntry = await getFileEntry(zipWriter, name, reader, { localHeaderInfo, dataDescriptorInfo }, options);
+	if (maximumEntrySize) {
+		zipWriter.pendingEntriesSize -= maximumEntrySize;
 	}
 	Object.assign(fileEntry, { name, comment, extraField });
 	return new Entry(fileEntry);
 }
 
-async function getFileEntry(zipWriter, name, reader, options) {
+async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	const {
 		files,
 		writer
@@ -321,7 +328,6 @@ async function getFileEntry(zipWriter, name, reader, options) {
 	let releaseLockCurrentFileEntry;
 	let writingBufferedData;
 	let fileWriter;
-	let fileWriterSize;
 	files.set(name, fileEntry);
 	try {
 		let lockPreviousFileEntry;
@@ -331,15 +337,20 @@ async function getFileEntry(zipWriter, name, reader, options) {
 		}
 		if (options.bufferedWrite || zipWriter.lockWriter || !dataDescriptor) {
 			fileWriter = new BlobWriter();
+			fileWriter.writable.size = 0;
 			bufferedWrite = true;
 			await initStream(writer);
 		} else {
 			fileWriter = writer;
 			zipWriter.lockWriter = Promise.resolve();
+			releaseLockWriter = () => delete zipWriter.lockWriter;
 		}
 		await initStream(fileWriter);
-		fileWriterSize = fileWriter.size;
-		fileEntry = await createFileEntry(reader, fileEntry, fileWriter.writable, zipWriter.config, options);
+		if (!bufferedWrite) {
+			await lockPreviousFileEntry;
+		}
+		fileEntry.writingData = true;
+		fileEntry = await createFileEntry(reader, fileWriter, fileEntry, entryInfo, zipWriter.config, options);
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
 		if (bufferedWrite) {
@@ -350,8 +361,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			writingBufferedData = true;
 			const { writable } = writer;
 			if (!dataDescriptor) {
-				const headerLength = 26;
-				const arrayBuffer = await sliceAsArrayBuffer(blob, 0, headerLength);
+				const arrayBuffer = await sliceAsArrayBuffer(blob, 0, 26);
 				const arrayBufferView = new DataView(arrayBuffer);
 				if (!fileEntry.encrypted || zipCrypto) {
 					setUint32(arrayBufferView, 14, fileEntry.signature);
@@ -364,7 +374,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 					setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
 				}
 				await writeData(writable, new Uint8Array(arrayBuffer));
-				blob = blob.slice(headerLength);
+				blob = blob.slice(arrayBuffer.byteLength);
 			}
 			await blob.stream().pipeTo(writable, { preventClose: true, signal });
 			writingBufferedData = false;
@@ -384,7 +394,11 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			if (error) {
 				error.corruptedEntry = true;
 			}
-			zipWriter.offset += fileWriter.size - fileWriterSize;
+			if (bufferedWrite) {
+				zipWriter.offset += fileWriter.writable.size;
+			} else {
+				zipWriter.offset = fileWriter.writable.size;
+			}
 		}
 		files.delete(name);
 		throw error;
@@ -412,7 +426,25 @@ async function getFileEntry(zipWriter, name, reader, options) {
 	}
 }
 
-async function createFileEntry(reader, pendingFileEntry, writable, config, options) {
+async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, config, options) {
+	const {
+		localHeaderInfo,
+		dataDescriptorInfo
+	} = entryInfo;
+	const {
+		localHeaderArray,
+		headerArray,
+		lastModDate,
+		rawLastModDate,
+		encrypted,
+		compressed,
+		version,
+		compressionMethod,
+		rawExtraFieldExtendedTimestamp,
+		rawExtraFieldNTFS,
+		rawExtraFieldAES
+	} = localHeaderInfo;
+	const { dataDescriptorArray } = dataDescriptorInfo;
 	const {
 		rawFilename,
 		lastAccessDate,
@@ -422,9 +454,7 @@ async function createFileEntry(reader, pendingFileEntry, writable, config, optio
 		zip64,
 		zipCrypto,
 		dataDescriptor,
-		dataDescriptorSignature,
 		directory,
-		version,
 		versionMadeBy,
 		rawComment,
 		rawExtraField,
@@ -440,8 +470,108 @@ async function createFileEntry(reader, pendingFileEntry, writable, config, optio
 		externalFileAttribute,
 		useCompressionStream
 	} = options;
-	const encrypted = Boolean(password && password.length);
+	const fileEntry = {
+		lock: pendingFileEntry.lock,
+		versionMadeBy,
+		zip64,
+		directory: Boolean(directory),
+		filenameUTF8: true,
+		rawFilename,
+		commentUTF8: true,
+		rawComment,
+		rawExtraFieldExtendedTimestamp,
+		rawExtraFieldNTFS,
+		rawExtraFieldAES,
+		rawExtraField,
+		extendedTimestamp,
+		msDosCompatible,
+		internalFileAttribute,
+		externalFileAttribute
+	};
+	let uncompressedSize = 0;
+	let signature;
+	let compressedSize = 0;
+	const { writable } = writer;
+	if (reader) {
+		reader.chunkSize = getChunkSize(config);
+		await writeData(writable, localHeaderArray);
+		const size = () => reader.size;
+		const readable = reader.readable;
+		readable.size = size;
+		const workerOptions = {
+			options: {
+				codecType: CODEC_DEFLATE,
+				level,
+				password,
+				encryptionStrength,
+				zipCrypto: encrypted && zipCrypto,
+				passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
+				signed: true,
+				compressed,
+				encrypted,
+				useWebWorkers,
+				useCompressionStream
+			},
+			config,
+			streamOptions: { signal, size, onstart, onprogress, onend },
+			codecConstructor: config.Deflate
+		};
+		const previousSize = writable.size;
+		signature = (await runWorker({ readable, writable }, workerOptions)).signature;
+		uncompressedSize = reader.size = readable.size();
+		compressedSize = writable.size - previousSize;
+	} else {
+		await writeData(writable, localHeaderArray);
+	}
+	const rawExtraFieldZip64 = zip64 ? new Uint8Array(EXTRAFIELD_LENGTH_ZIP64 + 4) : new Uint8Array();
+	if (reader) {
+		setEntryInfo({
+			signature,
+			rawExtraFieldZip64,
+			compressedSize,
+			uncompressedSize,
+			localHeaderInfo,
+			dataDescriptorInfo
+		}, options);
+	}
+	if (dataDescriptor) {
+		await writeData(writable, dataDescriptorArray);
+	}
+	Object.assign(fileEntry, {
+		compressedSize,
+		lastModDate,
+		rawLastModDate,
+		creationDate,
+		lastAccessDate,
+		encrypted,
+		length: localHeaderArray.length + compressedSize + dataDescriptorArray.length,
+		compressionMethod,
+		version,
+		headerArray,
+		signature,
+		rawExtraFieldZip64
+	});
+	return fileEntry;
+}
+
+function getLocalHeaderInfo(options) {
+	const {
+		rawFilename,
+		lastAccessDate,
+		creationDate,
+		password,
+		level,
+		zip64,
+		zipCrypto,
+		dataDescriptor,
+		directory,
+		rawExtraField,
+		encryptionStrength,
+		extendedTimestamp,
+	} = options;
+	let version = options.version || VERSION_DEFLATE;
 	const compressed = level !== 0 && !directory;
+	const encrypted = Boolean(password && password.length);
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
 		rawExtraFieldAES = new Uint8Array(EXTRAFIELD_DATA_AES.length + 2);
@@ -485,27 +615,6 @@ async function createFileEntry(reader, pendingFileEntry, writable, config, optio
 	} else {
 		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array();
 	}
-	const fileEntry = {
-		lock: pendingFileEntry.lock,
-		version: version || VERSION_DEFLATE,
-		versionMadeBy,
-		zip64,
-		directory: Boolean(directory),
-		filenameUTF8: true,
-		rawFilename,
-		commentUTF8: true,
-		rawComment,
-		rawExtraFieldZip64: zip64 ? new Uint8Array(EXTRAFIELD_LENGTH_ZIP64 + 4) : new Uint8Array(),
-		rawExtraFieldExtendedTimestamp,
-		rawExtraFieldNTFS,
-		rawExtraFieldAES,
-		rawExtraField,
-		extendedTimestamp,
-		msDosCompatible,
-		internalFileAttribute,
-		externalFileAttribute
-	};
-	let uncompressedSize = fileEntry.uncompressedSize = 0;
 	let bitFlag = BITFLAG_LANG_ENCODING_FLAG;
 	if (dataDescriptor) {
 		bitFlag = bitFlag | BITFLAG_DATA_DESCRIPTOR;
@@ -515,22 +624,21 @@ async function createFileEntry(reader, pendingFileEntry, writable, config, optio
 		compressionMethod = COMPRESSION_METHOD_DEFLATE;
 	}
 	if (zip64) {
-		fileEntry.version = fileEntry.version > VERSION_ZIP64 ? fileEntry.version : VERSION_ZIP64;
+		version = version > VERSION_ZIP64 ? version : VERSION_ZIP64;
 	}
 	if (encrypted) {
 		bitFlag = bitFlag | BITFLAG_ENCRYPTED;
 		if (!zipCrypto) {
-			fileEntry.version = fileEntry.version > VERSION_AES ? fileEntry.version : VERSION_AES;
+			version = version > VERSION_AES ? version : VERSION_AES;
 			compressionMethod = COMPRESSION_METHOD_AES;
 			if (compressed) {
-				fileEntry.rawExtraFieldAES[9] = COMPRESSION_METHOD_DEFLATE;
+				rawExtraFieldAES[9] = COMPRESSION_METHOD_DEFLATE;
 			}
 		}
 	}
-	fileEntry.compressionMethod = compressionMethod;
-	const headerArray = fileEntry.headerArray = new Uint8Array(26);
+	const headerArray = new Uint8Array(26);
 	const headerView = getDataView(headerArray);
-	setUint16(headerView, 0, fileEntry.version);
+	setUint16(headerView, 0, version);
 	setUint16(headerView, 2, bitFlag);
 	setUint16(headerView, 4, compressionMethod);
 	const dateArray = new Uint32Array(1);
@@ -559,39 +667,28 @@ async function createFileEntry(reader, pendingFileEntry, writable, config, optio
 	arraySet(localHeaderArray, rawExtraFieldExtendedTimestamp, 30 + rawFilename.length + rawExtraFieldAES.length);
 	arraySet(localHeaderArray, rawExtraFieldNTFS, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length);
 	arraySet(localHeaderArray, rawExtraField, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length);
-	let result;
-	let compressedSize = 0;
-	fileEntry.writingData = pendingFileEntry.writingData = true;
-	if (reader) {
-		reader.chunkSize = getChunkSize(config);
-		await writeData(writable, localHeaderArray);
-		const size = () => reader.size;
-		const readable = reader.readable;
-		readable.size = size;
-		const workerOptions = {
-			options: {
-				codecType: CODEC_DEFLATE,
-				level,
-				password,
-				encryptionStrength,
-				zipCrypto: encrypted && zipCrypto,
-				passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
-				signed: true,
-				compressed,
-				encrypted,
-				useWebWorkers,
-				useCompressionStream
-			},
-			config,
-			streamOptions: { signal, size, onstart, onprogress, onend },
-			codecConstructor: config.Deflate
-		};
-		result = await runWorker({ readable, writable }, workerOptions);
-		uncompressedSize = fileEntry.uncompressedSize = reader.size = readable.size();
-		compressedSize = result.size;
-	} else {
-		await writeData(writable, localHeaderArray);
-	}
+	return {
+		localHeaderArray,
+		headerArray,
+		headerView,
+		lastModDate,
+		rawLastModDate,
+		encrypted,
+		compressed,
+		version,
+		compressionMethod,
+		rawExtraFieldExtendedTimestamp,
+		rawExtraFieldNTFS,
+		rawExtraFieldAES
+	};
+}
+
+function getDataDescriptorInfo(options) {
+	const {
+		zip64,
+		dataDescriptor,
+		dataDescriptorSignature
+	} = options;
 	let dataDescriptorArray = new Uint8Array();
 	let dataDescriptorView, dataDescriptorOffset = 0;
 	if (dataDescriptor) {
@@ -602,51 +699,61 @@ async function createFileEntry(reader, pendingFileEntry, writable, config, optio
 			setUint32(dataDescriptorView, 0, DATA_DESCRIPTOR_RECORD_SIGNATURE);
 		}
 	}
-	if (reader) {
-		const { signature } = result;
-		if ((!encrypted || zipCrypto) && signature !== undefined) {
-			setUint32(headerView, 10, signature);
-			fileEntry.signature = signature;
-			if (dataDescriptor) {
-				setUint32(dataDescriptorView, dataDescriptorOffset, signature);
-			}
-		}
-		if (zip64) {
-			const rawExtraFieldZip64View = getDataView(fileEntry.rawExtraFieldZip64);
-			setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
-			setUint16(rawExtraFieldZip64View, 2, EXTRAFIELD_LENGTH_ZIP64);
-			setUint32(headerView, 14, MAX_32_BITS);
-			setBigUint64(rawExtraFieldZip64View, 12, BigInt(compressedSize));
-			setUint32(headerView, 18, MAX_32_BITS);
-			setBigUint64(rawExtraFieldZip64View, 4, BigInt(uncompressedSize));
-			if (dataDescriptor) {
-				setBigUint64(dataDescriptorView, dataDescriptorOffset + 4, BigInt(compressedSize));
-				setBigUint64(dataDescriptorView, dataDescriptorOffset + 12, BigInt(uncompressedSize));
-			}
-		} else {
-			setUint32(headerView, 14, compressedSize);
-			setUint32(headerView, 18, uncompressedSize);
-			if (dataDescriptor) {
-				setUint32(dataDescriptorView, dataDescriptorOffset + 4, compressedSize);
-				setUint32(dataDescriptorView, dataDescriptorOffset + 8, uncompressedSize);
-			}
+	return {
+		dataDescriptorArray,
+		dataDescriptorView,
+		dataDescriptorOffset
+	};
+}
+
+function setEntryInfo(entryInfo, options) {
+	const {
+		signature,
+		rawExtraFieldZip64,
+		compressedSize,
+		uncompressedSize,
+		localHeaderInfo,
+		dataDescriptorInfo
+	} = entryInfo;
+	const {
+		headerView,
+		encrypted
+	} = localHeaderInfo;
+	const {
+		dataDescriptorView,
+		dataDescriptorOffset
+	} = dataDescriptorInfo;
+	const {
+		zip64,
+		zipCrypto,
+		dataDescriptor
+	} = options;
+	if ((!encrypted || zipCrypto) && signature !== undefined) {
+		setUint32(headerView, 10, signature);
+		if (dataDescriptor) {
+			setUint32(dataDescriptorView, dataDescriptorOffset, signature);
 		}
 	}
-	if (dataDescriptor) {
-		await writeData(writable, dataDescriptorArray);
+	if (zip64) {
+		const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
+		setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
+		setUint16(rawExtraFieldZip64View, 2, EXTRAFIELD_LENGTH_ZIP64);
+		setUint32(headerView, 14, MAX_32_BITS);
+		setBigUint64(rawExtraFieldZip64View, 12, BigInt(compressedSize));
+		setUint32(headerView, 18, MAX_32_BITS);
+		setBigUint64(rawExtraFieldZip64View, 4, BigInt(uncompressedSize));
+		if (dataDescriptor) {
+			setBigUint64(dataDescriptorView, dataDescriptorOffset + 4, BigInt(compressedSize));
+			setBigUint64(dataDescriptorView, dataDescriptorOffset + 12, BigInt(uncompressedSize));
+		}
+	} else {
+		setUint32(headerView, 14, compressedSize);
+		setUint32(headerView, 18, uncompressedSize);
+		if (dataDescriptor) {
+			setUint32(dataDescriptorView, dataDescriptorOffset + 4, compressedSize);
+			setUint32(dataDescriptorView, dataDescriptorOffset + 8, uncompressedSize);
+		}
 	}
-	const length = localHeaderArray.length + compressedSize + dataDescriptorArray.length;
-	Object.assign(fileEntry, {
-		compressedSize,
-		lastModDate,
-		rawLastModDate,
-		creationDate,
-		lastAccessDate,
-		encrypted,
-		length,
-		writingData: false
-	});
-	return fileEntry;
 }
 
 async function closeFile(zipWriter, comment, options) {
@@ -784,6 +891,7 @@ function sliceAsArrayBuffer(blob, start, end) {
 async function writeData(writable, array) {
 	const streamWriter = writable.getWriter();
 	await streamWriter.ready;
+	writable.size += array.length;
 	await streamWriter.write(array);
 	streamWriter.releaseLock();
 }