@zip.js/zip.js 2.6.17 → 2.6.20

package/lib/core/codec-interface.js

@@ -27,6 +27,7 @@
  */
 
 // deno-lint-ignore-file no-this-alias
+/* global TransformStream */
 
 import {
 	InflateStream,
@@ -41,6 +42,7 @@ const MESSAGE_EVENT_TYPE = "message";
 const MESSAGE_START = "start";
 const MESSAGE_PULL = "pull";
 const MESSAGE_DATA = "data";
+const MESSAGE_ACK_DATA = "ack";
 const MESSAGE_CLOSE = "close";
 
 export {
@@ -53,6 +55,7 @@ export {
 	MESSAGE_START,
 	MESSAGE_PULL,
 	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
 	MESSAGE_CLOSE
 };
 
@@ -68,7 +71,17 @@ class Codec {
 
 		async function run(StreamConstructor) {
 			const stream = new StreamConstructor(codecConstructor, options, config);
-			await readable.pipeThrough(stream).pipeTo(writable, { preventClose: true, preventAbort: true });
+			await readable
+				.pipeThrough(stream)
+				.pipeThrough(new TransformStream({
+					transform(chunk, controller) {
+						if (chunk && chunk.length) {
+							writable.size += chunk.length;
+							controller.enqueue(chunk);
+						}
+					}
+				}))
+				.pipeTo(writable, { preventClose: true, preventAbort: true });
 			const { size, signature } = stream;
 			return { size, signature };
 		}

package/lib/core/codec-pool-worker.js

@@ -34,6 +34,7 @@ import {
 	MESSAGE_START,
 	MESSAGE_PULL,
 	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
 	MESSAGE_CLOSE
 } from "./codec-interface.js";
 
@@ -208,7 +209,9 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 				}
 				if (type == MESSAGE_DATA) {
 					await writer.ready;
+					workerData.writable.size += data.byteLength;
 					await writer.write(new Uint8Array(data));
+					sendMessage({ type: MESSAGE_ACK_DATA, messageId });
 				}
 				if (type == MESSAGE_CLOSE) {
 					close(null, result);

package/lib/core/io.js

@@ -78,7 +78,7 @@ class Reader extends Stream {
 	}
 }
 
-class WriterStream extends Stream {
+class Writer extends Stream {
 
 	constructor() {
 		super();
@@ -88,18 +88,15 @@ class WriterStream extends Stream {
 				return writer.writeUint8Array(chunk);
 			}
 		});
-		Object.defineProperty(this, "writable", {
+		Object.defineProperty(writer, "writable", {
 			get() {
 				return writable;
 			}
 		});
 	}
-}
-
-class Writer extends WriterStream {
 
-	writeUint8Array(array) {
-		this.size += array.length;
+	writeUint8Array() {
+		// abstract
 	}
 }
 
@@ -131,7 +128,6 @@ class TextWriter extends Writer {
 	}
 
 	writeUint8Array(array) {
-		super.writeUint8Array(array);
 		this.blob = new Blob([this.blob, array.buffer], { type: CONTENT_TYPE_TEXT_PLAIN });
 	}
 
@@ -186,7 +182,6 @@ class Data64URIWriter extends Writer {
 	}
 
 	writeUint8Array(array) {
-		super.writeUint8Array(array);
 		const writer = this;
 		let indexArray = 0;
 		let dataString = writer.pending;
@@ -483,18 +478,20 @@ class Uint8ArrayWriter extends Writer {
 
 	init(initSize = 0) {
 		super.init();
-		this.array = new Uint8Array(initSize);
+		const writer = this;
+		writer.offset = 0;
+		writer.array = new Uint8Array(initSize);
 	}
 
 	writeUint8Array(array) {
 		const writer = this;
-		if (writer.size + array.length > writer.array.length) {
+		if (writer.offset + array.length > writer.array.length) {
 			const previousArray = writer.array;
 			writer.array = new Uint8Array(previousArray.length + array.length);
 			writer.array.set(previousArray);
 		}
-		writer.array.set(array, writer.size);
-		super.writeUint8Array(array);
+		writer.array.set(array, writer.offset);
+		writer.offset += array.length;
 	}
 
 	getData() {

package/lib/core/streams/zip-entry-stream.js

@@ -167,15 +167,7 @@ function filterEmptyChunks(readable) {
 }
 
 function setReadable(stream, readable, flush) {
-	stream.size = 0;
-	readable = readable.pipeThrough(new TransformStream({
-		transform(chunk, controller) {
-			if (chunk && chunk.length) {
-				stream.size += chunk.length;
-				controller.enqueue(chunk);
-			}
-		}, flush
-	}));
+	readable = readable.pipeThrough(new TransformStream({ flush }));
 	Object.defineProperty(stream, "readable", {
 		get() {
 			return readable;

package/lib/core/z-worker-core.js

@@ -36,10 +36,12 @@ import {
 	MESSAGE_START,
 	MESSAGE_PULL,
 	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
 	MESSAGE_CLOSE
 } from "./codec-interface.js";
 
-const pendingMessages = new Map();
+const pendingPullMessages = new Map();
+const pendingDataMessages = new Map();
 let codec;
 let messageId = 0;
 
@@ -51,10 +53,15 @@ addEventListener(MESSAGE_EVENT_TYPE, async event => {
 			init(message);
 		}
 		if (type == MESSAGE_DATA) {
-			const { resolve } = pendingMessages.get(messageId);
-			pendingMessages.delete(messageId);
+			const resolve = pendingPullMessages.get(messageId);
+			pendingPullMessages.delete(messageId);
 			resolve({ value: new Uint8Array(data), done });
 		}
+		if (type == MESSAGE_ACK_DATA) {
+			const resolve = pendingDataMessages.get(messageId);
+			pendingDataMessages.delete(messageId);
+			resolve();
+		}
 	} catch (error) {
 		postMessage({ error: { message: error.message, stack: error.stack } });
 	}
@@ -79,7 +86,7 @@ async function init(message) {
 		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
 		const readable = new ReadableStream({
 			async pull(controller) {
-				let result = new Promise((resolve, reject) => pendingMessages.set(messageId, { resolve, reject }));
+				let result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
 				sendMessage({ type: MESSAGE_PULL, messageId });
 				messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
 				const { value, done } = await result;
@@ -90,14 +97,18 @@ async function init(message) {
 			}
 		}, strategy);
 		const writable = new WritableStream({
-			write(data) {
-				sendMessage({ type: MESSAGE_DATA, data });
+			async write(data) {
+				let resolveAckData;
+				const ackData = new Promise(resolve => resolveAckData = resolve);
+				pendingDataMessages.set(messageId, resolveAckData);
+				sendMessage({ type: MESSAGE_DATA, data, messageId });
+				messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
+				await ackData;
 			}
 		}, strategy);
 		codec = new Codec(codecConstructor, readable, writable, options, config);
 		const result = await codec.run();
 		sendMessage({ type: MESSAGE_CLOSE, result });
-
 	} catch (error) {
 		const { message, stack } = error;
 		postMessage({ error: { message, stack } });

package/lib/core/zip-fs-core.js

@@ -437,6 +437,11 @@ class FS {
 		await this.root.importData64URI(dataURI, options);
 	}
 
+	async importUint8Array(array, options) {
+		resetFS(this);
+		await this.root.importUint8Array(array, options);
+	}
+
 	async importHttpContent(url, options) {
 		resetFS(this);
 		await this.root.importHttpContent(url, options);

package/lib/core/zip-reader.js

@@ -322,6 +322,7 @@ class ZipEntry {
 		readable.offset = dataOffset;
 		readable.size = size;
 		const { writable } = writer;
+		writable.size = 0;
 		const signal = getOptionValue(zipEntry, options, "signal");
 		await initStream(writer, uncompressedSize);
 		const { onstart, onprogress, onend } = options;

package/lib/core/zip-writer.js

@@ -93,13 +93,16 @@ 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,
+			offset: writer.writable.size,
 			pendingCompressedSize: 0,
 			pendingAddFileCalls: new Set()
 		});
@@ -321,7 +324,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 +333,19 @@ 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 = await createFileEntry(reader, fileWriter, fileEntry, zipWriter.config, options);
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
 		if (bufferedWrite) {
@@ -350,8 +356,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 +369,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 +389,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 +421,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 	}
 }
 
-async function createFileEntry(reader, pendingFileEntry, writable, config, options) {
+async function createFileEntry(reader, writer, pendingFileEntry, config, options) {
 	const {
 		rawFilename,
 		lastAccessDate,
@@ -505,7 +514,7 @@ async function createFileEntry(reader, pendingFileEntry, writable, config, optio
 		internalFileAttribute,
 		externalFileAttribute
 	};
-	let uncompressedSize = fileEntry.uncompressedSize = 0;
+	let uncompressedSize = 0;
 	let bitFlag = BITFLAG_LANG_ENCODING_FLAG;
 	if (dataDescriptor) {
 		bitFlag = bitFlag | BITFLAG_DATA_DESCRIPTOR;
@@ -561,6 +570,7 @@ async function createFileEntry(reader, pendingFileEntry, writable, config, optio
 	arraySet(localHeaderArray, rawExtraField, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length);
 	let result;
 	let compressedSize = 0;
+	const { writable } = writer;
 	fileEntry.writingData = pendingFileEntry.writingData = true;
 	if (reader) {
 		reader.chunkSize = getChunkSize(config);
@@ -586,9 +596,10 @@ async function createFileEntry(reader, pendingFileEntry, writable, config, optio
 			streamOptions: { signal, size, onstart, onprogress, onend },
 			codecConstructor: config.Deflate
 		};
+		const previousSize = writable.size;
 		result = await runWorker({ readable, writable }, workerOptions);
-		uncompressedSize = fileEntry.uncompressedSize = reader.size = readable.size();
-		compressedSize = result.size;
+		uncompressedSize = reader.size = readable.size();
+		compressedSize = writable.size - previousSize;
 	} else {
 		await writeData(writable, localHeaderArray);
 	}
@@ -784,6 +795,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();
 }