@zip.js/zip.js 2.5.16 → 2.5.19

package/lib/core/codec-interface.js

@@ -26,7 +26,6 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global AbortController */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -42,12 +41,11 @@ const MESSAGE_EVENT_TYPE = "message";
 const MESSAGE_START = "start";
 const MESSAGE_PULL = "pull";
 const MESSAGE_DATA = "data";
-const MESSAGE_ABORT = "abort";
 const MESSAGE_CLOSE = "close";
 const ERR_ABORT = "AbortError";
 
 export {
-	createCodec,
+	Codec,
 	CODEC_DEFLATE,
 	CODEC_INFLATE,
 	ERR_INVALID_SIGNATURE,
@@ -56,34 +54,25 @@ export {
 	MESSAGE_START,
 	MESSAGE_PULL,
 	MESSAGE_DATA,
-	MESSAGE_ABORT,
 	MESSAGE_CLOSE,
 	ERR_ABORT
 };
 
-function createCodec(codecConstructor, readable, writable, options, config) {
-	const controller = new AbortController();
-	const { signal } = controller;
-	if (options.codecType.startsWith(CODEC_DEFLATE)) {
-		return {
-			run: () => run(DeflateStream),
-			abort
-		};
-	} else if (options.codecType.startsWith(CODEC_INFLATE)) {
-		return {
-			run: () => run(InflateStream),
-			abort
-		};
-	}
+class Codec {
 
-	async function run(StreamConstructor) {
-		const stream = new StreamConstructor(codecConstructor, options, config);
-		await readable.pipeThrough(stream, { signal }).pipeTo(writable, { preventClose: true });
-		const { length, signature } = stream;
-		return { length, signature };
-	}
+	constructor(codecConstructor, readable, writable, options, config) {
+		const { codecType } = options;
+		if (codecType.startsWith(CODEC_DEFLATE)) {
+			this.run = () => run(DeflateStream);
+		} else if (codecType.startsWith(CODEC_INFLATE)) {
+			this.run = () => run(InflateStream);
+		}
 
-	function abort() {
-		controller.abort();
+		async function run(StreamConstructor) {
+			const stream = new StreamConstructor(codecConstructor, options, config);
+			await readable.pipeThrough(stream).pipeTo(writable, { preventClose: true });
+			const { length, signature } = stream;
+			return { length, signature };
+		}
 	}
 }

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

@@ -29,62 +29,65 @@
 /* global Worker, URL, TransformStream */
 
 import {
-	createCodec,
+	Codec,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
 	MESSAGE_DATA,
-	MESSAGE_ABORT,
 	MESSAGE_CLOSE
 } from "./codec-interface.js";
 
 let classicWorkersSupported = true;
 
 export {
-	getWorker
+	CodecWorker
 };
 
-function getWorker(workerData, stream, workerOptions, onTaskFinished) {
-	const { readable, writable } = stream;
-	const { options, config, streamOptions, webWorker, scripts, codecConstructor } = workerOptions;
-	Object.assign(workerData, {
-		busy: true,
-		codecConstructor,
-		readable,
-		writable,
-		options: Object.assign({}, options),
-		scripts,
-		terminate() {
-			if (workerData.worker && !workerData.busy) {
-				workerData.worker.terminate();
-				workerData.interface = null;
+class CodecWorker {
+
+	constructor(workerData, stream, workerOptions, onTaskFinished) {
+		const { readable, writable } = stream;
+		const { options, config, streamOptions, webWorker, scripts, codecConstructor } = workerOptions;
+		Object.assign(workerData, {
+			busy: true,
+			codecConstructor,
+			readable,
+			writable,
+			options: Object.assign({}, options),
+			scripts,
+			terminate() {
+				if (workerData.worker && !workerData.busy) {
+					workerData.worker.terminate();
+					workerData.interface = null;
+				}
+			},
+			onTaskFinished() {
+				workerData.busy = false;
+				onTaskFinished(workerData);
 			}
-		},
-		onTaskFinished() {
-			workerData.busy = false;
-			onTaskFinished(workerData);
-		}
-	});
-	const { signal, size, onstart, onprogress, onend } = streamOptions;
-	if (signal || onstart || onprogress || onend) {
+		});
+		const { signal, onstart, onprogress, size, onend } = streamOptions;
 		let chunkOffset = 0;
 		const transformer = {};
 		if (onstart) {
 			transformer.start = () => callHandler(onstart, size());
 		}
-		if (onprogress) {
-			transformer.transform = async (chunk, controller) => {
-				chunkOffset += chunk.length;
+		transformer.transform = async (chunk, controller) => {
+			chunkOffset += chunk.length;
+			if (onprogress) {
 				await callHandler(onprogress, chunkOffset, size());
-				controller.enqueue(chunk);
-			};
-		}
-		if (onend) {
-			transformer.flush = () => callHandler(onend);
-		}
+			}
+			controller.enqueue(chunk);
+		};
+		transformer.flush = () => {
+			readable.size = () => chunkOffset;
+			if (onend) {
+				callHandler(onend, chunkOffset);
+			}
+		};
 		workerData.readable = readable.pipeThrough(new TransformStream(transformer, { highWaterMark: 1, size: () => config.chunkSize }), { signal });
+		return webWorker ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 	}
-	return webWorker ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 }
 
 async function callHandler(handler, ...parameters) {
@@ -96,17 +99,15 @@ async function callHandler(handler, ...parameters) {
 }
 
 function createWorkerInterface(workerData, config) {
-	const interfaceCodec = createCodec(workerData.codecConstructor, workerData.readable, workerData.writable, workerData.options, config);
+	const interfaceCodec = new Codec(workerData.codecConstructor, workerData.readable, workerData.writable, workerData.options, config);
 	const { onTaskFinished } = workerData;
 	const codec = {
-		abort() {
-			interfaceCodec.abort();
-			onTaskFinished();
-		},
 		async run() {
-			const result = await interfaceCodec.run();
-			onTaskFinished();
-			return result;
+			try {
+				return await interfaceCodec.run();
+			} finally {
+				onTaskFinished();
+			}
 		}
 	};
 	return codec;
@@ -121,8 +122,7 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		result: new Promise((resolve, reject) => {
 			workerData.resolveResult = resolve;
 			workerData.rejectResult = reject;
-		}),
-		aborted: false
+		})
 	});
 	if (!workerData.interface) {
 		if (!classicWorkersSupported) {
@@ -137,12 +137,6 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		}
 		workerData.worker.addEventListener(MESSAGE_EVENT_TYPE, onMessage, false);
 		workerData.interface = {
-			abort() {
-				workerData.aborted = true;
-				sendMessage({ type: MESSAGE_ABORT });
-				workerData.writer.releaseLock();
-				workerData.onTaskFinished();
-			},
 			run() {
 				const { options } = workerData;
 				const scripts = workerData.scripts.slice(1);
@@ -221,7 +215,7 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		}
 
 		function close(error, result) {
-			if (error && !workerData.aborted) {
+			if (error) {
 				rejectResult(error);
 			} else {
 				resolveResult(result);

package/lib/core/codec-pool.js

@@ -35,7 +35,7 @@ import {
 	ERR_INVALID_PASSWORD,
 	ERR_ABORT
 } from "./codec-interface.js";
-import { getWorker } from "./codec-pool-worker.js";
+import { CodecWorker } from "./codec-pool-worker.js";
 
 let pool = [];
 const pendingRequests = [];
@@ -60,27 +60,26 @@ async function runWorker(stream, workerOptions) {
 	workerOptions.webWorker = !streamCopy && (useWebWorkers || (useWebWorkers === undefined && config.useWebWorkers));
 	workerOptions.scripts = workerOptions.webWorker && workerScripts ? workerScripts[codecType] : [];
 	options.useCompressionStream = useCompressionStream === undefined ? config.useCompressionStream : useCompressionStream;
-	let codec;
+	let worker;
 	if (pool.length < config.maxWorkers) {
 		const workerData = { indexWorker };
 		indexWorker++;
 		pool.push(workerData);
-		codec = getWorker(workerData, stream, workerOptions, onTaskFinished);
+		worker = new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
 	} else {
 		const workerData = pool.find(workerData => !workerData.busy);
 		if (workerData) {
 			clearTerminateTimeout(workerData);
-			codec = getWorker(workerData, stream, workerOptions, onTaskFinished);
+			worker = new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
 		} else {
-			codec = await new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
+			worker = await new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
 		}
 	}
-	const { signal } = streamOptions;
 	try {
-		return await codec.run(signal);
+		return await worker.run();
 	} catch (error) {
+		const { signal } = streamOptions;
 		if (signal && signal.aborted && (signal.reason == error || error.name == ERR_ABORT)) {
-			codec.abort();
 			throw new Error(ERR_ABORT);
 		} else {
 			throw error;
@@ -90,7 +89,7 @@ async function runWorker(stream, workerOptions) {
 	function onTaskFinished(workerData) {
 		if (pendingRequests.length) {
 			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
-			resolve(getWorker(workerData, stream, workerOptions, onTaskFinished));
+			resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished));
 		} else if (workerData.worker) {
 			const { terminateWorkerTimeout } = config;
 			clearTerminateTimeout(workerData);

package/lib/core/io.js

@@ -55,13 +55,14 @@ class Stream {
 
 class Reader extends Stream {
 
-	getReadable({ offset, size, chunkSize } = { offset: 0, chunkSize: DEFAULT_CHUNK_SIZE }) {
+	get readable() {
 		const reader = this;
-		return new ReadableStream({
+		const readable = new ReadableStream({
 			start() {
 				this.chunkOffset = 0;
 			},
 			async pull(controller) {
+				const { offset = 0, chunkSize = DEFAULT_CHUNK_SIZE, size } = readable;
 				const { chunkOffset } = this;
 				controller.enqueue(await reader.readUint8Array(offset + chunkOffset, Math.min(chunkSize, size() - chunkOffset)));
 				if (chunkOffset + chunkSize > size()) {
@@ -71,6 +72,7 @@ class Reader extends Stream {
 				}
 			}
 		});
+		return readable;
 	}
 }
 
@@ -247,30 +249,13 @@ function flushArrayBuffers(blobWriter) {
 	blobWriter.arrayBuffers = [];
 }
 
-class ReadableStreamReader {
+class ReadableStreamReader extends Stream {
 
 	constructor(readable) {
-		const reader = this;
+		super();
 		if (!readable) {
-			readable = new ReadableStream({});
+			this.readable = new ReadableStream({});
 		}
-		reader.readable = readable.pipeThrough(new TransformStream({
-			transform(chunk, controller) {
-				if (chunk) {
-					reader.size += chunk.length;
-					controller.enqueue(chunk);
-				}
-			}
-		}));
-		reader.size = 0;
-	}
-
-	init() {
-		this.initialized = true;
-	}
-
-	getReadable() {
-		return this.readable;
 	}
 }
 
@@ -288,15 +273,6 @@ class WritableStreamWriter extends Writer {
 			}
 		});
 	}
-
-	async getData() {
-		const writer = this;
-		const { writable } = writer;
-		if (!writer.preventClose) {
-			await writable.getWriter().close();
-		}
-		return writable;
-	}
 }
 
 class FetchReader extends Reader {

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

@@ -29,14 +29,13 @@
 /* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream */
 
 import {
-	createCodec,
+	Codec,
 	CODEC_DEFLATE,
 	CODEC_INFLATE,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
 	MESSAGE_DATA,
-	MESSAGE_ABORT,
 	MESSAGE_CLOSE
 } from "./codec-interface.js";
 
@@ -56,9 +55,6 @@ addEventListener(MESSAGE_EVENT_TYPE, async event => {
 			pendingMessages.delete(messageId);
 			resolve({ value: new Uint8Array(data), done });
 		}
-		if (type == MESSAGE_ABORT) {
-			codec.abort();
-		}
 	} catch (error) {
 		postMessage({ error: { message: error.message, stack: error.stack } });
 	}
@@ -98,7 +94,7 @@ async function init(message) {
 				sendMessage({ type: MESSAGE_DATA, data });
 			}
 		}, strategy);
-		codec = createCodec(codecConstructor, readable, writable, options, config);
+		codec = new Codec(codecConstructor, readable, writable, options, config);
 		const result = await codec.run();
 		sendMessage({ type: MESSAGE_CLOSE, result });
 

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

@@ -117,7 +117,7 @@ class ZipFileEntry extends ZipEntry {
 		} else {
 			zipEntry.reader = new zipEntry.Reader(zipEntry.data, options);
 			await zipEntry.reader.init();
-			if (!writer.initialized) {
+			if (writer.init && !writer.initialized) {
 				await writer.init();
 			}
 			zipEntry.uncompressedSize = zipEntry.reader.size;

package/lib/core/zip-reader.js

@@ -266,9 +266,6 @@ class ZipEntry {
 			compressedSize
 		} = zipEntry;
 		const localDirectory = zipEntry.localDirectory = {};
-		if (!reader.initialized) {
-			await reader.init();
-		}
 		let dataArray = await readUint8Array(reader, offset, 30);
 		const dataView = getDataView(dataArray);
 		let password = getOptionValue(zipEntry, options, "password");
@@ -301,10 +298,13 @@ class ZipEntry {
 		}
 		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
 		const size = () => compressedSize;
-		const readable = reader.getReadable({ offset: dataOffset, size, chunkSize: getChunkSize(config) });
+		const readable = reader.readable;
+		readable.offset = dataOffset;
+		readable.size = size;
+		readable.chunkSize = getChunkSize(config);
 		const { writable } = writer;
 		const signal = getOptionValue(zipEntry, options, "signal");
-		if (!writer.initialized) {
+		if (writer.init && !writer.initialized) {
 			await writer.init();
 		}
 		const { onstart, onprogress, onend } = options;
@@ -327,7 +327,10 @@ class ZipEntry {
 			codecConstructor: config.Inflate
 		};
 		await runWorker({ readable, writable }, workerOptions);
-		return writer.getData();
+		if (!writer.preventClose) {
+			await writable.getWriter().close();
+		}
+		return writer.getData ? writer.getData() : writable;
 	}
 }
 

package/lib/core/zip-writer.js

@@ -126,11 +126,16 @@ class ZipWriter {
 	}
 
 	async close(comment = new Uint8Array(), options = {}) {
-		while (this.pendingAddFileCalls.size) {
-			await Promise.all(Array.from(this.pendingAddFileCalls));
+		const { pendingAddFileCalls, writer } = this;
+		const { writable } = writer;
+		while (pendingAddFileCalls.size) {
+			await Promise.all(Array.from(pendingAddFileCalls));
 		}
 		await closeFile(this, comment, options);
-		return this.writer.getData();
+		if (!writer.preventClose) {
+			await writable.getWriter().close();
+		}
+		return writer.getData ? writer.getData() : writable;
 	}
 }
 
@@ -220,10 +225,14 @@ async function addFile(zipWriter, name, reader, options) {
 	const internalFileAttribute = getOptionValue(zipWriter, options, "internalFileAttribute") || 0;
 	const externalFileAttribute = getOptionValue(zipWriter, options, "externalFileAttribute") || 0;
 	if (reader) {
-		if (!reader.initialized) {
+		if (reader.init && !reader.initialized) {
 			await reader.init();
 		}
-		uncompressedSize = reader.size;
+		if (reader.size === undefined) {
+			options.dataDescriptor = true;
+		} else {
+			uncompressedSize = reader.size;
+		}
 		maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 	}
 	let zip64 = options.zip64 || zipWriter.options.zip64 || false;
@@ -305,7 +314,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			bufferedWrite = true;
 		} else {
 			zipWriter.lockWrite = new Promise(resolve => resolveLockUnbufferedWrite = resolve);
-			if (!writer.initialized) {
+			if (writer.init && !writer.initialized) {
 				await writer.init();
 			}
 			fileWriter = writer;
@@ -524,7 +533,9 @@ async function createFileEntry(reader, writable, config, options) {
 		await writeUint8Array(writable, localHeaderArray);
 		fileEntry.dataWritten = true;
 		const size = () => reader.size;
-		const readable = reader.getReadable({ offset: 0, size, chunkSize: getChunkSize(config) });
+		const readable = reader.readable;
+		readable.size = size;
+		readable.chunkSize = getChunkSize(config);
 		const workerOptions = {
 			options: {
 				codecType: CODEC_DEFLATE,
@@ -544,7 +555,7 @@ async function createFileEntry(reader, writable, config, options) {
 			codecConstructor: config.Deflate
 		};
 		result = await runWorker({ readable, writable }, workerOptions);
-		uncompressedSize = fileEntry.uncompressedSize = reader.size;
+		uncompressedSize = fileEntry.uncompressedSize = reader.size = readable.size();
 		compressedSize = result.length;
 	} else {
 		await writeUint8Array(writable, localHeaderArray);