@zip.js/zip.js 2.8.50 → 2.8.51

package/lib/core/zip-fs.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global WritableStream, AbortController */
+/* global WritableStream, AbortController, DOMException */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -72,6 +72,8 @@ import { toCompatibleReadable, toCompatibleWritable } from "./util/compatible-st
 const ERR_ENTRY_EXISTS = "Entry filename already exists";
 const ERR_READABLE_CONSUMED = "Readable stream already consumed";
 const ERR_ABORT_EXPORT = "zipjs-abort-export";
+const ERR_ABORTED = "The operation was aborted";
+const ABORT_ERROR_NAME = "AbortError";
 const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
 const INTERPRETED_EXTRA_FIELD_TYPES = new Set([
 	EXTRAFIELD_TYPE_ZIP64,
@@ -524,6 +526,10 @@ class ZipDirectoryEntry extends ZipEntry {
 		}
 	}
 
+	getChildren(options = {}) {
+		return collectChildren(this, options.recursive);
+	}
+
 	isPasswordProtected() {
 		const children = this.children;
 		for (let childIndex = 0; childIndex < children.length; childIndex++) {
@@ -615,6 +621,10 @@ class FS {
 		return this.root.getChildByName(name);
 	}
 
+	getChildren(options) {
+		return this.root.getChildren(options);
+	}
+
 	addDirectory(name, options) {
 		return this.root.addDirectory(name, options);
 	}
@@ -723,7 +733,7 @@ class FS {
 }
 
 const fs = { FS, ZipDirectoryEntry, ZipFileEntry };
-export { fs, ERR_ENTRY_EXISTS, ERR_READABLE_CONSUMED };
+export { fs, ERR_ENTRY_EXISTS, ERR_READABLE_CONSUMED, ERR_ABORTED };
 
 function getTotalSize(entries, propertyName) {
 	let size = 0;
@@ -875,103 +885,101 @@ function getUserExtraField(extraField) {
 async function exportZip(zipWriter, entry, totalSize, options, readers) {
 	const selectedEntry = entry;
 	const entryOffsets = new Map();
-	await process(zipWriter, entry);
+	if (options.bufferedWrite) {
+		await processChildren(entry);
+	} else {
+		for (const child of entry.getChildren({ recursive: true })) {
+			await addChild(child);
+		}
+	}
 
-	async function process(zipWriter, entry) {
-		await exportChild();
+	async function processChildren(entry) {
+		const results = await Promise.allSettled(entry.children.map(async child => {
+			await addChild(child);
+			await processChildren(child);
+		}));
+		const errorResult = results.find(result => result.status == "rejected");
+		if (errorResult) {
+			throw errorResult.reason;
+		}
+	}
 
-		async function exportChild() {
-			if (options.bufferedWrite) {
-				const results = await Promise.allSettled(entry.children.map(processChild));
-				const errorResult = results.find(result => result.status == "rejected");
-				if (errorResult) {
-					throw errorResult.reason;
+	async function addChild(child) {
+		const name = options.relativePath ? child.getRelativeName(selectedEntry) : child.getFullname();
+		const childOptions = child.options || {};
+		let zipEntryOptions = {};
+		if (child.data instanceof Entry) {
+			const {
+				externalFileAttributes,
+				versionMadeBy,
+				comment,
+				lastModDate,
+				creationDate,
+				lastAccessDate,
+				uncompressedSize,
+				encrypted,
+				zipCrypto,
+				crc32,
+				compressionMethod,
+				extraFieldAES,
+				internalFileAttributes,
+				extraField,
+				uid,
+				gid
+			} = child.data;
+			zipEntryOptions = {
+				externalFileAttributes,
+				versionMadeBy,
+				comment,
+				lastModDate,
+				creationDate,
+				lastAccessDate,
+				internalFileAttributes
+			};
+			const userExtraField = getUserExtraField(extraField);
+			if (userExtraField) {
+				zipEntryOptions.extraField = userExtraField;
+			}
+			if (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE) {
+				Object.assign(zipEntryOptions, {
+					uid,
+					gid,
+					unixExtraFieldType: options.unixExtraFieldType || INFOZIP_EXTRA_FIELD_TYPE
+				});
+			}
+			if (child.passThrough) {
+				let level, encryptionStrength;
+				if (compressionMethod === 0) {
+					level = 0;
 				}
-			} else {
-				for (const child of entry.children) {
-					await processChild(child);
+				if (extraFieldAES) {
+					encryptionStrength = extraFieldAES.strength;
 				}
-			}
-		}
-
-		async function processChild(child) {
-			const name = options.relativePath ? child.getRelativeName(selectedEntry) : child.getFullname();
-			const childOptions = child.options || {};
-			let zipEntryOptions = {};
-			if (child.data instanceof Entry) {
-				const {
-					externalFileAttributes,
-					versionMadeBy,
-					comment,
-					lastModDate,
-					creationDate,
-					lastAccessDate,
-					uncompressedSize,
+				zipEntryOptions = Object.assign(zipEntryOptions, {
+					passThrough: true,
 					encrypted,
 					zipCrypto,
 					crc32,
-					compressionMethod,
-					extraFieldAES,
-					internalFileAttributes,
-					extraField,
-					uid,
-					gid
-				} = child.data;
-				zipEntryOptions = {
-					externalFileAttributes,
-					versionMadeBy,
-					comment,
-					lastModDate,
-					creationDate,
-					lastAccessDate,
-					internalFileAttributes
-				};
-				const userExtraField = getUserExtraField(extraField);
-				if (userExtraField) {
-					zipEntryOptions.extraField = userExtraField;
-				}
-				if (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE) {
-					Object.assign(zipEntryOptions, {
-						uid,
-						gid,
-						unixExtraFieldType: options.unixExtraFieldType || INFOZIP_EXTRA_FIELD_TYPE
-					});
-				}
-				if (child.passThrough) {
-					let level, encryptionStrength;
-					if (compressionMethod === 0) {
-						level = 0;
-					}
-					if (extraFieldAES) {
-						encryptionStrength = extraFieldAES.strength;
-					}
-					zipEntryOptions = Object.assign(zipEntryOptions, {
-						passThrough: true,
-						encrypted,
-						zipCrypto,
-						crc32,
-						uncompressedSize,
-						level,
-						encryptionStrength,
-						compressionMethod
-					});
-				}
+					uncompressedSize,
+					level,
+					encryptionStrength,
+					compressionMethod
+				});
 			}
-			await zipWriter.add(name, readers.get(child), Object.assign({}, options, zipEntryOptions, childOptions, {
-				directory: child.directory,
-				onprogress: async indexProgress => {
-					if (options.onprogress) {
-						entryOffsets.set(name, indexProgress);
-						try {
-							await options.onprogress(Array.from(entryOffsets.values()).reduce((previousValue, currentValue) => previousValue + currentValue), totalSize);
-						} catch {
-							// ignored
-						}
+		}
+		await zipWriter.add(name, readers.get(child), Object.assign({}, options, zipEntryOptions, childOptions, {
+			directory: child.directory,
+			onprogress: async indexProgress => {
+				if (options.onprogress) {
+					entryOffsets.set(name, indexProgress);
+					try {
+						await options.onprogress(Array.from(entryOffsets.values()).reduce((previousValue, currentValue) => previousValue + currentValue), totalSize);
+					} catch {
+						// ignored
 					}
 				}
-			}));
-			await process(zipWriter, child);
-		}
+			}
+		}));
 	}
 }
 
@@ -1027,6 +1035,7 @@ async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 	const { signal } = abortController;
 	const releaseSignal = forwardAbort(options.signal, abortController);
 	const exportedEntryNames = [];
+	let exportAborted = false;
 	try {
 		await exportChildren(zipEntry, directoryHandle);
 	} catch (error) {
@@ -1059,10 +1068,10 @@ async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 
 	async function exportChild(child, parentHandle) {
 		if (signal.aborted) {
-			if (isExportAborted(signal.reason)) {
+			if (exportAborted || isExportAborted(signal.reason)) {
 				return;
 			}
-			throw signal.reason;
+			throw signal.reason === UNDEFINED_VALUE ? new DOMException(ERR_ABORTED, ABORT_ERROR_NAME) : signal.reason;
 		}
 		try {
 			if (child.directory) {
@@ -1071,22 +1080,27 @@ async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 			} else {
 				const fileHandle = await parentHandle.getFileHandle(child.name, { create: true });
 				const writable = await fileHandle.createWritable();
-				await child.getData({ writable }, Object.assign({}, options, {
-					signal,
-					onprogress: async progress => {
-						if (options.onprogress) {
-							writtenSizes.set(child.id, progress);
-							try {
-								await options.onprogress(Array.from(writtenSizes.values()).reduce((previousValue, currentValue) => previousValue + currentValue, 0), totalSize);
-							} catch {
-								// ignored
+				try {
+					await child.getData({ writable }, Object.assign({}, options, {
+						signal,
+						onprogress: async progress => {
+							if (options.onprogress) {
+								writtenSizes.set(child.id, progress);
+								try {
+									await options.onprogress(Array.from(writtenSizes.values()).reduce((previousValue, currentValue) => previousValue + currentValue, 0), totalSize);
+								} catch {
+									// ignored
+								}
 							}
 						}
-					}
-				}));
+					}));
+				} catch (error) {
+					throw exportAborted ? new Error(ERR_ABORT_EXPORT) : error;
+				}
 				exportedEntryNames.push(child.getRelativeName(zipEntry));
 			}
 		} catch (error) {
+			exportAborted = true;
 			abortController.abort(new Error(ERR_ABORT_EXPORT));
 			try {
 				if (error.entryName === UNDEFINED_VALUE) {
@@ -1158,6 +1172,21 @@ function resetFS(fs) {
 	fs.root = new ZipDirectoryEntry(fs);
 }
 
+function collectChildren(directory, recursive) {
+	const children = [];
+	const pendingDirectories = [directory];
+	let directoryIndex = 0;
+	while (directoryIndex < pendingDirectories.length) {
+		for (const child of pendingDirectories[directoryIndex++].children) {
+			children.push(child);
+			if (recursive) {
+				pendingDirectories.push(child);
+			}
+		}
+	}
+	return children;
+}
+
 function registerEntries(fs, entry) {
 	const pendingEntries = [entry];
 	while (pendingEntries.length) {

package/package.json

@@ -3,7 +3,7 @@
   "description": "A JavaScript library to zip and unzip files in the browser, Deno and Node.js",
   "author": "Gildas Lormeau",
   "license": "BSD-3-Clause",
-  "version": "2.8.50",
+  "version": "2.8.51",
   "type": "module",
   "keywords": [
     "zip",