@zip.js/zip.js 2.6.32 → 2.6.34

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

@@ -1,289 +0,0 @@
-/*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright 
- notice, this list of conditions and the following disclaimer in 
- the documentation and/or other materials provided with the distribution.
-
- 3. The names of the authors may not be used to endorse or promote products
- derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
- INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
- FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
- INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
- OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/* global Worker, URL, TransformStream, WritableStream */
-
-import {
-	Codec,
-	MESSAGE_EVENT_TYPE,
-	MESSAGE_START,
-	MESSAGE_PULL,
-	MESSAGE_DATA,
-	MESSAGE_ACK_DATA,
-	MESSAGE_CLOSE
-} from "./codec-interface.js";
-
-let workersSupported;
-let classicWorkersSupported = true;
-let transferStreamsSupported = true;
-
-export {
-	CodecWorker
-};
-
-class CodecWorker {
-
-	constructor(workerData, stream, workerOptions, onTaskFinished) {
-		const { readable, writable } = stream;
-		const { options, config, streamOptions, useWebWorkers, transferStreams, scripts } = workerOptions;
-		Object.assign(workerData, {
-			busy: true,
-			readable,
-			writable,
-			options: Object.assign({}, options),
-			scripts,
-			transferStreams,
-			terminate() {
-				if (workerData.worker && !workerData.busy) {
-					workerData.worker.terminate();
-					workerData.interface = null;
-				}
-			},
-			onTaskFinished() {
-				workerData.busy = false;
-				onTaskFinished(workerData);
-			}
-		});
-		const { signal, onstart, onprogress, size, onend } = streamOptions;
-		let chunkOffset = 0;
-		const transformer = {};
-		if (onstart) {
-			transformer.start = () => callHandler(onstart, size);
-		}
-		transformer.transform = async (chunk, controller) => {
-			chunkOffset += chunk.length;
-			if (onprogress) {
-				await callHandler(onprogress, chunkOffset, size);
-			}
-			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 });
-		if (workersSupported === undefined) {
-			workersSupported = typeof Worker != "undefined";
-		}
-		return useWebWorkers && workersSupported ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
-	}
-}
-
-async function callHandler(handler, ...parameters) {
-	try {
-		await handler(...parameters);
-	} catch (_error) {
-		// ignored
-	}
-}
-
-function createWorkerInterface(workerData, config) {
-	const interfaceCodec = new Codec(workerData.readable, workerData.writable, workerData.options, config);
-	const { onTaskFinished } = workerData;
-	const codec = {
-		async run() {
-			try {
-				return await interfaceCodec.run();
-			} finally {
-				onTaskFinished();
-			}
-		}
-	};
-	return codec;
-}
-
-function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
-	const workerOptions = { type: "module" };
-	Object.assign(workerData, {
-		streams: {},
-		result: new Promise((resolve, reject) => {
-			workerData.resolveResult = resolve;
-			workerData.rejectResult = reject;
-		})
-	});
-	if (!workerData.interface) {
-		if (!classicWorkersSupported) {
-			workerData.worker = getWorker(workerOptions);
-		} else {
-			try {
-				workerData.worker = getWorker({});
-			} catch (_error) {
-				classicWorkersSupported = false;
-				workerData.worker = getWorker(workerOptions);
-			}
-		}
-		workerData.worker.addEventListener(MESSAGE_EVENT_TYPE, onMessage, false);
-		workerData.interface = {
-			async run() {
-				const { readable, options } = workerData;
-				const writer = workerData.writable.getWriter();
-				let resolveStreamClosed, streamClosed;
-				streamClosed = new Promise(resolve => resolveStreamClosed = resolve);
-				const writable = new WritableStream({
-					async write(chunk) {
-						await writer.ready;
-						await writer.write(chunk);
-					},
-					async close() {
-						writer.releaseLock();
-						resolveStreamClosed();
-					},
-					abort(reason) {
-						writer.abort(reason);
-					}
-				});
-				const scripts = workerData.scripts.slice(1);
-				const message = { type: MESSAGE_START, scripts, options, config: { chunkSize } };
-				if (workerData.transferStreams && transferStreamsSupported) {
-					const streamsTransferred = sendMessage({ ...message, readable, writable });
-					if (!streamsTransferred) {
-						transferStreamsSupported = false;
-						initStreams(readable, writable);
-					}
-				} else {
-					sendMessage(message);
-					initStreams(readable, writable);
-				}
-				const result = await workerData.result;
-				try {
-					await writable.close();
-				} catch (_error) {
-					// ignored
-				}
-				await streamClosed;
-				return result;
-			}
-		};
-	}
-	return workerData.interface;
-
-	function initStreams(readable, writable) {
-		Object.assign(workerData.streams, {
-			reader: readable.getReader(),
-			writer: writable.getWriter()
-		});
-	}
-
-	function getWorker(options) {
-		let url, scriptUrl;
-		url = workerData.scripts[0];
-		if (typeof url == "function") {
-			url = url();
-		}
-		try {
-			scriptUrl = new URL(url, baseURL);
-		} catch (_error) {
-			scriptUrl = url;
-		}
-		return new Worker(scriptUrl, options);
-	}
-
-	function sendMessage(message) {
-		const { worker, writer, onTaskFinished } = workerData;
-		try {
-			let { data, readable, writable } = message;
-			const transferrables = [];
-			if (data) {
-				const { buffer, length } = data;
-				if (length != buffer.byteLength) {
-					data = new Uint8Array(data);
-				}
-				message.data = data.buffer;
-				transferrables.push(message.data);
-			}
-			if (readable) {
-				transferrables.push(readable);
-			}
-			if (writable) {
-				transferrables.push(writable);
-			}
-			if (transferrables.length) {
-				try {
-					worker.postMessage(message, transferrables);
-					return true;
-				} catch (error) {
-					message.readable = message.writable = null;
-					worker.postMessage(message);
-				}
-			} else {
-				worker.postMessage(message);
-			}
-		} catch (error) {
-			if (writer) {
-				writer.releaseLock();
-			}
-			onTaskFinished();
-			throw error;
-		}
-	}
-
-	async function onMessage(event) {
-		const message = event.data;
-		const { resolveResult, rejectResult, onTaskFinished } = workerData;
-		const { reader, writer } = workerData.streams;
-		const { type, data, messageId, result } = message;
-		const reponseError = message.error;
-		try {
-			if (reponseError) {
-				const { message, stack, code, name } = reponseError;
-				const error = new Error(message);
-				Object.assign(error, { stack, code, name });
-				close(error);
-			} else {
-				if (type == MESSAGE_PULL) {
-					const { value, done } = await reader.read();
-					sendMessage({ type: MESSAGE_DATA, data: value, done, messageId });
-				}
-				if (type == MESSAGE_DATA) {
-					await writer.ready;
-					await writer.write(new Uint8Array(data));
-					sendMessage({ type: MESSAGE_ACK_DATA, messageId });
-				}
-				if (type == MESSAGE_CLOSE) {
-					close(null, result);
-				}
-			}
-		} catch (error) {
-			close(error);
-		}
-
-		function close(error, result) {
-			if (error) {
-				rejectResult(error);
-			} else {
-				resolveResult(result);
-			}
-			if (writer) {
-				writer.releaseLock();
-			}
-			onTaskFinished();
-		}
-	}
-}