@zip.js/zip.js 2.8.50 → 2.8.51

package/dist/zip-fs-core.js

@@ -7043,6 +7043,8 @@
 	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,
@@ -7495,6 +7497,10 @@
 			}
 		}
 
+		getChildren(options = {}) {
+			return collectChildren(this, options.recursive);
+		}
+
 		isPasswordProtected() {
 			const children = this.children;
 			for (let childIndex = 0; childIndex < children.length; childIndex++) {
@@ -7586,6 +7592,10 @@
 			return this.root.getChildByName(name);
 		}
 
+		getChildren(options) {
+			return this.root.getChildren(options);
+		}
+
 		addDirectory(name, options) {
 			return this.root.addDirectory(name, options);
 		}
@@ -7845,103 +7855,101 @@
 	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);
-			}
+				}
+			}));
 		}
 	}
 
@@ -7997,6 +8005,7 @@
 		const { signal } = abortController;
 		const releaseSignal = forwardAbort(options.signal, abortController);
 		const exportedEntryNames = [];
+		let exportAborted = false;
 		try {
 			await exportChildren(zipEntry, directoryHandle);
 		} catch (error) {
@@ -8029,10 +8038,10 @@
 
 		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) {
@@ -8041,22 +8050,27 @@
 				} 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) {
@@ -8128,6 +8142,21 @@
 		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) {
@@ -8147,6 +8176,7 @@
 		}
 	}
 
+	exports.ERR_ABORTED = ERR_ABORTED;
 	exports.ERR_ENTRY_EXISTS = ERR_ENTRY_EXISTS;
 	exports.ERR_READABLE_CONSUMED = ERR_READABLE_CONSUMED;
 	exports.fs = fs;