@zip.js/zip.js 2.8.50 → 2.8.51

package/index.cjs

@@ -8598,6 +8598,8 @@ U(setDefaultConfiguration);
 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,
@@ -9050,6 +9052,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++) {
@@ -9141,6 +9147,10 @@ class FS {
 		return this.root.getChildByName(name);
 	}
 
+	getChildren(options) {
+		return this.root.getChildren(options);
+	}
+
 	addDirectory(name, options) {
 		return this.root.addDirectory(name, options);
 	}
@@ -9400,103 +9410,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);
-		}
+			}
+		}));
 	}
 }
 
@@ -9552,6 +9560,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) {
@@ -9584,10 +9593,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) {
@@ -9596,22 +9605,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) {
@@ -9683,6 +9697,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) {
@@ -9801,6 +9830,7 @@ exports.BlobReader = BlobReader;
 exports.BlobWriter = BlobWriter;
 exports.Data64URIReader = Data64URIReader;
 exports.Data64URIWriter = Data64URIWriter;
+exports.ERR_ABORTED = ERR_ABORTED;
 exports.ERR_AMBIGUOUS_ARCHIVE = ERR_AMBIGUOUS_ARCHIVE;
 exports.ERR_BAD_FORMAT = ERR_BAD_FORMAT;
 exports.ERR_CENTRAL_DIRECTORY_NOT_FOUND = ERR_CENTRAL_DIRECTORY_NOT_FOUND;

package/index.d.cts

@@ -2815,6 +2815,23 @@ export class ZipDirectoryEntry extends ZipEntry {
    * @returns A {@link ZipFileEntry} or a {@link ZipDirectoryEntry} instance (use the {@link ZipFileEntry#directory} and {@link ZipDirectoryEntry#directory} properties to differentiate entries).
    */
   getChildByName(name: string): ZipEntry | undefined;
+  /**
+   * Gets the children of the directory
+   *
+   * @remarks The returned array is a snapshot taken when the method is called: entries added or removed
+   * afterwards are not reflected, and an entry removed while the array is being iterated is still present
+   * but detached from the filesystem.
+   *
+   * With `recursive`, the descendants are ordered level by level, i.e. the children of a directory come
+   * before the children of its subdirectories, like the result of `readdir(path, { recursive: true })` in
+   * Node.js. This is also the order in which `{@link ZipDirectoryEntry}#export*()` writes them.
+   *
+   * Unlike {@link FS#entries}, the directory itself is not included and removed entries leave no empty slot.
+   *
+   * @param options The options.
+   * @returns The array of {@link ZipEntry} instances.
+   */
+  getChildren(options?: ZipDirectoryEntryGetChildrenOptions): ZipEntry[];
   /**
    * Adds a directory
    *
@@ -3064,6 +3081,10 @@ export class ZipDirectoryEntry extends ZipEntry {
    * Running the same export again is the supported way to recover, since directories are merged and
    * files are overwritten.
    *
+   * @remarks An entry flagged as a symbolic link by its {@link EntryMetaData#externalFileAttributes} is written
+   * as a regular file whose content is the path of the link target, because the File System Access API cannot
+   * create symbolic links.
+   *
    * @param directoryHandle The target `FileSystemDirectoryHandle` instance.
    * @param options The options.
    * @returns A promise resolving to the target `FileSystemDirectoryHandle` instance.
@@ -3096,6 +3117,18 @@ export interface ZipDirectoryEntryImportHttpOptions
   extends ZipReaderConstructorOptions,
     HttpOptions {}
 
+/**
+ * Represents the options passed to {@link ZipDirectoryEntry#getChildren} and {@link FS#getChildren}.
+ */
+export interface ZipDirectoryEntryGetChildrenOptions {
+  /**
+   * `true` to return all the descendants of the directory instead of its direct children only.
+   *
+   * @defaultValue false
+   */
+  recursive?: boolean;
+}
+
 /**
  * Represents the options passed to `{@link ZipDirectoryEntry}#export*()`.
  */
@@ -3156,6 +3189,7 @@ export interface FS
   extends Pick<
     ZipDirectoryEntry,
     | "getChildByName"
+    | "getChildren"
     | "addDirectory"
     | "addText"
     | "addBlob"
@@ -3504,6 +3538,15 @@ export const ERR_ENTRY_EXISTS: string;
  * Readable stream already consumed error (thrown by the filesystem API when a readable stream is read more than once)
  */
 export const ERR_READABLE_CONSUMED: string;
+/**
+ * Aborted operation error (thrown by {@link ZipDirectoryEntry#exportFileSystemHandle} when it is aborted via
+ * {@link ZipReaderOptions#signal} on platforms which do not support the `reason` argument of
+ * `AbortController#abort()`)
+ *
+ * @remarks The reason passed by the caller is discarded by these platforms and cannot be recovered, so a
+ * `DOMException` named `AbortError` carrying this message is thrown in its place.
+ */
+export const ERR_ABORTED: string;
 /**
  * Unsupported context error (thrown when {@link createSyncAccessHandleTempStream} is used outside a dedicated worker)
  */

package/index.d.ts

@@ -2815,6 +2815,23 @@ export class ZipDirectoryEntry extends ZipEntry {
    * @returns A {@link ZipFileEntry} or a {@link ZipDirectoryEntry} instance (use the {@link ZipFileEntry#directory} and {@link ZipDirectoryEntry#directory} properties to differentiate entries).
    */
   getChildByName(name: string): ZipEntry | undefined;
+  /**
+   * Gets the children of the directory
+   *
+   * @remarks The returned array is a snapshot taken when the method is called: entries added or removed
+   * afterwards are not reflected, and an entry removed while the array is being iterated is still present
+   * but detached from the filesystem.
+   *
+   * With `recursive`, the descendants are ordered level by level, i.e. the children of a directory come
+   * before the children of its subdirectories, like the result of `readdir(path, { recursive: true })` in
+   * Node.js. This is also the order in which `{@link ZipDirectoryEntry}#export*()` writes them.
+   *
+   * Unlike {@link FS#entries}, the directory itself is not included and removed entries leave no empty slot.
+   *
+   * @param options The options.
+   * @returns The array of {@link ZipEntry} instances.
+   */
+  getChildren(options?: ZipDirectoryEntryGetChildrenOptions): ZipEntry[];
   /**
    * Adds a directory
    *
@@ -3064,6 +3081,10 @@ export class ZipDirectoryEntry extends ZipEntry {
    * Running the same export again is the supported way to recover, since directories are merged and
    * files are overwritten.
    *
+   * @remarks An entry flagged as a symbolic link by its {@link EntryMetaData#externalFileAttributes} is written
+   * as a regular file whose content is the path of the link target, because the File System Access API cannot
+   * create symbolic links.
+   *
    * @param directoryHandle The target `FileSystemDirectoryHandle` instance.
    * @param options The options.
    * @returns A promise resolving to the target `FileSystemDirectoryHandle` instance.
@@ -3096,6 +3117,18 @@ export interface ZipDirectoryEntryImportHttpOptions
   extends ZipReaderConstructorOptions,
     HttpOptions {}
 
+/**
+ * Represents the options passed to {@link ZipDirectoryEntry#getChildren} and {@link FS#getChildren}.
+ */
+export interface ZipDirectoryEntryGetChildrenOptions {
+  /**
+   * `true` to return all the descendants of the directory instead of its direct children only.
+   *
+   * @defaultValue false
+   */
+  recursive?: boolean;
+}
+
 /**
  * Represents the options passed to `{@link ZipDirectoryEntry}#export*()`.
  */
@@ -3156,6 +3189,7 @@ export interface FS
   extends Pick<
     ZipDirectoryEntry,
     | "getChildByName"
+    | "getChildren"
     | "addDirectory"
     | "addText"
     | "addBlob"
@@ -3504,6 +3538,15 @@ export const ERR_ENTRY_EXISTS: string;
  * Readable stream already consumed error (thrown by the filesystem API when a readable stream is read more than once)
  */
 export const ERR_READABLE_CONSUMED: string;
+/**
+ * Aborted operation error (thrown by {@link ZipDirectoryEntry#exportFileSystemHandle} when it is aborted via
+ * {@link ZipReaderOptions#signal} on platforms which do not support the `reason` argument of
+ * `AbortController#abort()`)
+ *
+ * @remarks The reason passed by the caller is discarded by these platforms and cannot be recovered, so a
+ * `DOMException` named `AbortError` carrying this message is thrown in its place.
+ */
+export const ERR_ABORTED: string;
 /**
  * Unsupported context error (thrown when {@link createSyncAccessHandleTempStream} is used outside a dedicated worker)
  */