@zip.js/zip.js 2.5.2 → 2.5.5

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) {
+			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;
 	}

package/lib/core/io.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Blob, FileReader, atob, btoa, XMLHttpRequest, document, fetch */
+/* global Blob, FileReader, atob, btoa, XMLHttpRequest, document, fetch, ReadableStream, WritableStream */
 
 const ERR_HTTP_STATUS = "HTTP error ";
 const ERR_HTTP_RANGE = "HTTP Range not supported";
@@ -40,6 +40,7 @@ const HTTP_HEADER_RANGE = "Range";
 const HTTP_METHOD_HEAD = "HEAD";
 const HTTP_METHOD_GET = "GET";
 const HTTP_RANGE_UNIT = "bytes";
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
 
 class Stream {
 
@@ -53,9 +54,39 @@ class Stream {
 }
 
 class Reader extends Stream {
+
+	getStream({ offset, size, chunkSize } = { offset: 0, chunkSize: DEFAULT_CHUNK_SIZE }) {
+		const reader = this;
+		return new ReadableStream({
+			start() {
+				this.chunkOffset = 0;
+			},
+			async pull(controller) {
+				const { chunkOffset } = this;
+				controller.enqueue(await reader.readUint8Array(offset + chunkOffset, Math.min(chunkSize, size() - chunkOffset)));
+				if (chunkOffset + chunkSize > size()) {
+					controller.close();
+				} else {
+					this.chunkOffset += chunkSize;
+				}
+			}
+		});
+	}
+}
+
+class WriterStream extends Stream {
+
+	getStream() {
+		const writer = this;
+		return new WritableStream({
+			write(chunk) {
+				return writer.writeUint8Array(chunk);
+			}
+		});
+	}
 }
 
-class Writer extends Stream {
+class Writer extends WriterStream {
 
 	writeUint8Array(array) {
 		this.size += array.length;
@@ -70,9 +101,10 @@ class TextReader extends Reader {
 	}
 
 	init() {
+		const reader = this;
 		super.init();
-		this.blobReader.init();
-		this.size = this.blobReader.size;
+		reader.blobReader.init();
+		reader.size = reader.blobReader.size;
 	}
 
 	readUint8Array(offset, length) {
@@ -94,14 +126,15 @@ class TextWriter extends Writer {
 	}
 
 	getData() {
-		if (this.blob.text) {
-			return this.blob.text();
+		const writer = this;
+		if (writer.blob.text) {
+			return writer.blob.text();
 		} else {
 			const reader = new FileReader();
 			return new Promise((resolve, reject) => {
 				reader.onload = event => resolve(event.target.result);
 				reader.onerror = () => reject(reader.error);
-				reader.readAsText(this.blob, this.encoding);
+				reader.readAsText(writer.blob, writer.encoding);
 			});
 		}
 	}
@@ -111,19 +144,21 @@ class Data64URIReader extends Reader {
 
 	constructor(dataURI) {
 		super();
-		this.dataURI = dataURI;
+		const reader = this;
+		reader.dataURI = dataURI;
 		let dataEnd = dataURI.length;
 		while (dataURI.charAt(dataEnd - 1) == "=") {
 			dataEnd--;
 		}
-		this.dataStart = dataURI.indexOf(",") + 1;
-		this.size = Math.floor((dataEnd - this.dataStart) * 0.75);
+		reader.dataStart = dataURI.indexOf(",") + 1;
+		reader.size = Math.floor((dataEnd - reader.dataStart) * 0.75);
 	}
 
 	readUint8Array(offset, length) {
 		const dataArray = new Uint8Array(length);
 		const start = Math.floor(offset / 3) * 4;
-		const bytes = atob(this.dataURI.substring(start + this.dataStart, Math.ceil((offset + length) / 3) * 4 + this.dataStart));
+		const dataStart = this.dataStart;
+		const bytes = atob(this.dataURI.substring(start + dataStart, Math.ceil((offset + length) / 3) * 4 + dataStart));
 		const delta = offset - Math.floor(start / 4) * 3;
 		for (let indexByte = delta; indexByte < delta + length; indexByte++) {
 			dataArray[indexByte - delta] = bytes.charCodeAt(indexByte);
@@ -142,20 +177,21 @@ class Data64URIWriter extends Writer {
 
 	writeUint8Array(array) {
 		super.writeUint8Array(array);
+		const writer = this;
 		let indexArray = 0;
-		let dataString = this.pending;
-		const delta = this.pending.length;
-		this.pending = "";
+		let dataString = writer.pending;
+		const delta = writer.pending.length;
+		writer.pending = "";
 		for (indexArray = 0; indexArray < (Math.floor((delta + array.length) / 3) * 3) - delta; indexArray++) {
 			dataString += String.fromCharCode(array[indexArray]);
 		}
 		for (; indexArray < array.length; indexArray++) {
-			this.pending += String.fromCharCode(array[indexArray]);
+			writer.pending += String.fromCharCode(array[indexArray]);
 		}
 		if (dataString.length > 2) {
-			this.data += btoa(dataString);
+			writer.data += btoa(dataString);
 		} else {
-			this.pending = dataString;
+			writer.pending = dataString;
 		}
 	}
 
@@ -173,14 +209,15 @@ class BlobReader extends Reader {
 	}
 
 	async readUint8Array(offset, length) {
-		if (this.blob.arrayBuffer) {
-			return new Uint8Array(await this.blob.slice(offset, offset + length).arrayBuffer());
+		const reader = this;
+		if (reader.blob.arrayBuffer) {
+			return new Uint8Array(await reader.blob.slice(offset, offset + length).arrayBuffer());
 		} else {
 			const reader = new FileReader();
 			return new Promise((resolve, reject) => {
 				reader.onload = event => resolve(new Uint8Array(event.target.result));
 				reader.onerror = () => reject(reader.error);
-				reader.readAsArrayBuffer(this.blob.slice(offset, offset + length));
+				reader.readAsArrayBuffer(reader.blob.slice(offset, offset + length));
 			});
 		}
 	}
@@ -197,21 +234,23 @@ class BlobWriter extends Writer {
 
 	writeUint8Array(array) {
 		super.writeUint8Array(array);
-		if (this.arrayBuffers.length == this.arrayBuffersMaxlength) {
-			flushArrayBuffers(this);
+		const writer = this;
+		if (writer.arrayBuffers.length == writer.arrayBuffersMaxlength) {
+			flushArrayBuffers(writer);
 		}
-		this.arrayBuffers.push(array.buffer);
+		writer.arrayBuffers.push(array.buffer);
 	}
 
 	getData() {
-		if (!this.blob) {
-			if (this.arrayBuffers.length) {
-				flushArrayBuffers(this);
+		const writer = this;
+		if (!writer.blob) {
+			if (writer.arrayBuffers.length) {
+				flushArrayBuffers(writer);
 			}
-			this.blob = this.pendingBlob;
-			initArrayBuffers(this);
+			writer.blob = writer.pendingBlob;
+			initArrayBuffers(writer);
 		}
-		return this.blob;
+		return writer.blob;
 	}
 }
 
@@ -229,78 +268,38 @@ class ReadableStreamReader {
 
 	constructor(readableStream) {
 		this.readableStream = readableStream;
-		this.reader = readableStream.getReader();
 		this.size = Infinity;
-		this.index = 0;
-		this.currentSize = 0;
-		this.pendingValue = new Uint8Array();
 	}
 
-	init() {
+	init(size) {
+		this.size = size;
 		this.initialized = true;
 	}
 
-	async readUint8Array(index, length) {
-		if (this.index != index) {
-			throw new Error(ERR_NOT_SEEKABLE_READER);
-		}
-		let data = new Uint8Array(length);
-		let size = 0, done;
-		do {
-			const result = await this.reader.read();
-			let { value } = result;
-			done = result.done;
-			if (value) {
-				this.currentSize += value.length;
-			} else {
-				value = this.pendingValue;
-				this.pendingValue = new Uint8Array();
-			}
-			if (this.pendingValue.length) {
-				const newValue = new Uint8Array(this.pendingValue.length + value.length);
-				newValue.set(this.pendingValue);
-				newValue.set(value, this.pendingValue.length);
-				this.pendingValue = new Uint8Array();
-				value = newValue;
-			}
-			if (size + value.length > length) {
-				data.set(value.subarray(0, length), size);
-				this.pendingValue = value.subarray(length);
-				size += length;
-			} else {
-				data.set(value, size);
-				size += value.length;
-			}
-		} while (size < length && !done);
-		if (done && this.size == Infinity) {
-			this.size = this.currentSize;
-		}
-		if (this.size < length) {
-			data = data.slice(0, this.size);
-			length = this.size;
-		}
-		this.index += length;
-		return data;
+	getStream() {
+		return this.readableStream;
 	}
 }
 
 class WritableStreamWriter extends Writer {
 
-	constructor(writableStream) {
+	constructor(writable) {
 		super();
-		this.writableStream = writableStream;
-		this.writer = writableStream.getWriter();
+		const writer = this;
+		writer.writable = writable;
 	}
 
 	async writeUint8Array(array) {
 		await this.writer.ready;
-		return this.writer.write(array);
+		return this.writable.getWriter().write(array);
+	}
+
+	getStream() {
+		return this.writable;
 	}
 
 	async getData() {
-		await this.writer.ready;
-		await this.writer.close();
-		return this.writableStream;
+		return this.writable;
 	}
 }
 
@@ -308,15 +307,16 @@ class FetchReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		this.url = url;
-		this.preventHeadRequest = options.preventHeadRequest;
-		this.useRangeHeader = options.useRangeHeader;
-		this.forceRangeRequests = options.forceRangeRequests;
-		this.options = Object.assign({}, options);
-		delete this.options.preventHeadRequest;
-		delete this.options.useRangeHeader;
-		delete this.options.forceRangeRequests;
-		delete this.options.useXHR;
+		const reader = this;
+		reader.url = url;
+		reader.preventHeadRequest = options.preventHeadRequest;
+		reader.useRangeHeader = options.useRangeHeader;
+		reader.forceRangeRequests = options.forceRangeRequests;
+		reader.options = Object.assign({}, options);
+		delete reader.options.preventHeadRequest;
+		delete reader.options.useRangeHeader;
+		delete reader.options.forceRangeRequests;
+		delete reader.options.useXHR;
 	}
 
 	async init() {
@@ -333,11 +333,12 @@ class XHRReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		this.url = url;
-		this.preventHeadRequest = options.preventHeadRequest;
-		this.useRangeHeader = options.useRangeHeader;
-		this.forceRangeRequests = options.forceRangeRequests;
-		this.options = options;
+		const reader = this;
+		reader.url = url;
+		reader.preventHeadRequest = options.preventHeadRequest;
+		reader.useRangeHeader = options.useRangeHeader;
+		reader.forceRangeRequests = options.forceRangeRequests;
+		reader.options = options;
 	}
 
 	async init() {
@@ -540,10 +541,11 @@ class Uint8ArrayWriter extends Writer {
 
 	writeUint8Array(array) {
 		super.writeUint8Array(array);
-		const previousArray = this.array;
-		this.array = new Uint8Array(previousArray.length + array.length);
-		this.array.set(previousArray);
-		this.array.set(array, previousArray.length);
+		const writer = this;
+		const previousArray = writer.array;
+		writer.array = new Uint8Array(previousArray.length + array.length);
+		writer.array.set(previousArray);
+		writer.array.set(array, previousArray.length);
 	}
 
 	getData() {