@zip.js/zip.js 2.5.3 → 2.5.7

package/lib/core/{engine.js → codec-interface.js}

@@ -26,62 +26,64 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const MINIMUM_CHUNK_SIZE = 64;
-const ERR_ABORT = "Abort error";
+/* global AbortController */
+// deno-lint-ignore-file no-this-alias
+
+import {
+	InflateStream,
+	DeflateStream,
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE
+} from "./streams/zip-entry-stream.js";
+
+const CODEC_DEFLATE = "deflate";
+const CODEC_INFLATE = "inflate";
+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 {
-	ERR_ABORT,
-	processData
+	createCodec,
+	CODEC_DEFLATE,
+	CODEC_INFLATE,
+	ERR_INVALID_SIGNATURE,
+	ERR_INVALID_PASSWORD,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ABORT,
+	MESSAGE_CLOSE,
+	ERR_ABORT
 };
 
-async function processData(codec, reader, writer, offset, inputLengthGetter, config, options) {
-	const chunkSize = Math.max(config.chunkSize, MINIMUM_CHUNK_SIZE);
-	const signal = options.signal;
-	let length = 0;
-	let chunkOffset = 0;
-
-	const result = new Promise((resolve, reject) => {
-		codec.pull = async () => {
-			testAborted(signal, codec);
-			const inputLength = inputLengthGetter();
-			let currentChunkOffset = chunkOffset;
-			chunkOffset += chunkSize;
-			const value = await reader.readUint8Array(currentChunkOffset + offset, Math.min(chunkSize, inputLength - currentChunkOffset));
-			const done = chunkOffset > inputLength;
-			return { value, done };
+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
 		};
-		codec.ondata = async ({ value, done }) => {
-			try {
-				testAborted(signal, codec);
-				const inputLength = inputLengthGetter();
-				const { data, signature } = value;
-				if (data && data.length) {
-					length += data.length;
-					await writer.writeUint8Array(data);
-				}
-				if (options.onprogress) {
-					try {
-						options.onprogress(chunkOffset, inputLength);
-					} catch (error) {
-						// ignored
-					}
-				}
-				if (done) {
-					resolve({ signature, length });
-				}
-			} catch (error) {
-				reject(error);
-			}
+	} else if (options.codecType.startsWith(CODEC_INFLATE)) {
+		return {
+			run: () => run(InflateStream),
+			abort
 		};
-		codec.onerror = reject;
-	});
-	await codec.start();
-	return result;
-}
+	}
+
+	async function run(StreamConstructor) {
+		const stream = new StreamConstructor(codecConstructor, options, config);
+		await readable.pipeThrough(stream, { signal }).pipeTo(writable);
+		const { length, signature } = stream;
+		return { length, signature };
+	}
 
-function testAborted(signal, codec) {
-	if (signal && signal.aborted) {
-		codec.abort();
-		throw new Error(ERR_ABORT);
+	function abort() {
+		controller.abort();
 	}
 }

package/lib/core/{codecs/codec-pool-worker.js → codec-pool-worker.js}

@@ -26,9 +26,17 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Worker, URL */
-
-import { createCodec, MESSAGE_EVENT_TYPE, MESSAGE_START, MESSAGE_PULL, MESSAGE_DATA, MESSAGE_ABORT } from "./codec.js";
+/* global Worker, URL, TransformStream */
+
+import {
+	createCodec,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ABORT,
+	MESSAGE_CLOSE
+} from "./codec-interface.js";
 
 let classicWorkersSupported = true;
 
@@ -36,10 +44,12 @@ export {
 	getWorker
 };
 
-function getWorker(workerData, codecConstructor, options, config, onTaskFinished, webWorker, scripts) {
+function getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts) {
 	Object.assign(workerData, {
 		busy: true,
 		codecConstructor,
+		readable,
+		writable,
 		options: Object.assign({}, options),
 		scripts,
 		terminate() {
@@ -53,27 +63,50 @@ function getWorker(workerData, codecConstructor, options, config, onTaskFinished
 			onTaskFinished(workerData);
 		}
 	});
+	const { signal, onprogress, size } = streamOptions;
+	if (signal || onprogress) {
+		let chunkOffset = 0;
+		const transformer = {};
+		if (onprogress) {
+			transformer.transform = (chunk, controller) => {
+				chunkOffset += chunk.length;
+				try {
+					onprogress(chunkOffset, size());
+				} catch (_error) {
+					// ignored
+				}
+				controller.enqueue(chunk);
+			};
+		}
+		workerData.readable = readable.pipeThrough(new TransformStream(transformer), { signal });
+	}
 	return webWorker ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 }
 
 function createWorkerInterface(workerData, config) {
-	const interfaceCodec = createCodec(workerData.codecConstructor, workerData.options, config);
+	const interfaceCodec = createCodec(workerData.codecConstructor, workerData.readable, workerData.writable, workerData.options, config);
 	const codec = {
 		abort() {
 			interfaceCodec.abort();
 			workerData.onTaskFinished();
 		},
-		start() {
-			return interfaceCodec.start();
+		run() {
+			const result = interfaceCodec.run();
+			workerData.onTaskFinished();
+			return result;
 		}
 	};
-	interfaceCodec.pull = () => codec.pull();
-	interfaceCodec.ondata = data => ondata(workerData, codec, data);
 	return codec;
 }
 
 function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	const workerOptions = { type: "module" };
+	workerData.reader = workerData.readable.getReader();
+	workerData.writer = workerData.writable.getWriter();
+	workerData.result = new Promise((resolve, reject) => {
+		workerData.resolveResult = resolve;
+		workerData.rejectResult = reject;
+	});
 	if (!workerData.interface) {
 		if (!classicWorkersSupported) {
 			workerData.worker = getWorker(workerOptions);
@@ -91,10 +124,11 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 				sendMessage({ type: MESSAGE_ABORT });
 				workerData.onTaskFinished();
 			},
-			start() {
+			run() {
 				const options = workerData.options;
 				const scripts = workerData.scripts.slice(1);
 				sendMessage({ type: MESSAGE_START, scripts, options, config: { chunkSize } });
+				return workerData.result;
 			}
 		};
 	}
@@ -136,39 +170,31 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	async function onMessage(event) {
 		const message = event.data;
 		const reponseError = message.error;
-		const codec = workerData.interface;
 		try {
 			if (reponseError) {
 				const error = new Error(reponseError.message);
 				error.stack = reponseError.stack;
-				codec.onerror(error);
+				workerData.rejectResult(error);
 				workerData.onTaskFinished();
 			} else {
 				if (message.type == MESSAGE_PULL) {
-					const { value, done } = await codec.pull();
+					const { value, done } = await workerData.reader.read();
 					sendMessage({ type: MESSAGE_DATA, data: value, done, messageId: message.messageId });
 				}
 				if (message.type == MESSAGE_DATA) {
-					const { value } = message.data;
-					if (value && value.data) {
-						value.data = new Uint8Array(value.data);
-					}
-					await ondata(workerData, codec, message.data);
+					let { data } = message;
+					data = new Uint8Array(data);
+					await workerData.writer.ready;
+					workerData.writer.write(data);
+				}
+				if (message.type == MESSAGE_CLOSE) {
+					workerData.resolveResult(message.result);
+					workerData.onTaskFinished();
 				}
 			}
 		} catch (error) {
-			codec.onerror(error);
+			workerData.rejectResult(error);
 			workerData.onTaskFinished();
 		}
 	}
-}
-
-async function ondata(workerData, codec, data) {
-	let { value, done } = data;
-	if (done) {
-		await codec.ondata({ value: { data: value.data, signature: value.signature }, done });
-		workerData.onTaskFinished();
-	} else if (value.data) {
-		await codec.ondata({ value: { data: value.data } });
-	}
 }

package/lib/core/{codecs/codec-pool.js → codec-pool.js}

@@ -28,47 +28,66 @@
 
 /* global setTimeout, clearTimeout */
 
-import { CODEC_INFLATE, CODEC_DEFLATE, ERR_INVALID_SIGNATURE, ERR_INVALID_PASSWORD } from "./codec.js";
+import {
+	CODEC_INFLATE,
+	CODEC_DEFLATE,
+	ERR_INVALID_SIGNATURE,
+	ERR_INVALID_PASSWORD,
+	ERR_ABORT
+} from "./codec-interface.js";
 import { getWorker } from "./codec-pool-worker.js";
 
 let pool = [];
 const pendingRequests = [];
 
 export {
-	createCodec,
+	runCodec,
 	terminateWorkers,
 	CODEC_DEFLATE,
 	CODEC_INFLATE,
 	ERR_INVALID_SIGNATURE,
-	ERR_INVALID_PASSWORD
+	ERR_INVALID_PASSWORD,
+	ERR_ABORT
 };
 
 let indexWorker = 0;
 
-function createCodec(codecConstructor, options, config) {
+async function runCodec(codecConstructor, readable, writable, options, config, streamOptions) {
 	const streamCopy = !options.compressed && !options.signed && !options.encrypted;
 	const webWorker = !streamCopy && (options.useWebWorkers || (options.useWebWorkers === undefined && config.useWebWorkers));
 	const scripts = webWorker && config.workerScripts ? config.workerScripts[options.codecType] : [];
 	options.useCompressionStream = options.useCompressionStream === undefined ? config.useCompressionStream : options.useCompressionStream;
+	let codec;
 	if (pool.length < config.maxWorkers) {
 		const workerData = { indexWorker };
 		indexWorker++;
 		pool.push(workerData);
-		return getWorker(workerData, codecConstructor, options, config, onTaskFinished, webWorker, scripts);
+		codec = getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts);
 	} else {
 		const workerData = pool.find(workerData => !workerData.busy);
 		if (workerData) {
 			clearTerminateTimeout(workerData);
-			return getWorker(workerData, codecConstructor, options, config, onTaskFinished, webWorker, scripts);
+			codec = getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts);
+		} else {
+			codec = await new Promise(resolve => pendingRequests.push({ resolve, codecConstructor, readable, writable, options, webWorker, scripts }));
+		}
+	}
+	const { signal } = streamOptions;
+	try {
+		return await codec.run(signal);
+	} catch (error) {
+		if (signal && signal.aborted && (signal.reason == error || error.name == ERR_ABORT)) {
+			codec.abort();
+			throw new Error(ERR_ABORT);
 		} else {
-			return new Promise(resolve => pendingRequests.push({ resolve, codecConstructor, options, webWorker, scripts }));
+			throw error;
 		}
 	}
 
 	function onTaskFinished(workerData) {
 		if (pendingRequests.length) {
-			const [{ resolve, codecConstructor, options, webWorker, scripts }] = pendingRequests.splice(0, 1);
-			resolve(getWorker(workerData, codecConstructor, options, config, onTaskFinished, webWorker, scripts));
+			const [{ resolve, codecConstructor, readable, writable, options, webWorker, scripts }] = pendingRequests.splice(0, 1);
+			resolve(getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts));
 		} else if (workerData.worker) {
 			clearTerminateTimeout(workerData);
 			if (Number.isFinite(config.terminateWorkerTimeout) && config.terminateWorkerTimeout >= 0) {

package/lib/core/configuration.js

@@ -28,6 +28,7 @@
 
 /* global navigator */
 
+const MINIMUM_CHUNK_SIZE = 64;
 const DEFAULT_CONFIGURATION = {
 	chunkSize: 512 * 1024,
 	maxWorkers: (typeof navigator != "undefined" && navigator.hardwareConcurrency) || 2,
@@ -40,13 +41,18 @@ const config = Object.assign({}, DEFAULT_CONFIGURATION);
 
 export {
 	configure,
-	getConfiguration
+	getConfiguration,
+	getChunkSize
 };
 
 function getConfiguration() {
 	return config;
 }
 
+function getChunkSize(config) {
+	return Math.max(config.chunkSize, MINIMUM_CHUNK_SIZE);
+}
+
 function configure(configuration) {
 	if (configuration.baseURL !== undefined) {
 		config.baseURL = configuration.baseURL;
@@ -60,6 +66,9 @@ function configure(configuration) {
 	if (configuration.terminateWorkerTimeout !== undefined) {
 		config.terminateWorkerTimeout = configuration.terminateWorkerTimeout;
 	}
+	if (configuration.useCompressionStream !== undefined) {
+		config.useCompressionStream = configuration.useCompressionStream;
+	}
 	if (configuration.useWebWorkers !== undefined) {
 		config.useWebWorkers = configuration.useWebWorkers;
 	}