@zip.js/zip.js 2.8.26 → 2.8.28

package/lib/core/zip-fs.js

@@ -54,12 +54,15 @@ import {
 } from "./zip-entry.js";
 import { UNDEFINED_VALUE } from "./constants.js";
 
+const ERR_ENTRY_EXISTS = "Entry filename already exists";
+const ERR_READABLE_CONSUMED = "Readable stream already consumed";
+
 class ZipEntry {
 
 	constructor(fs, name, params, parent) {
 		const zipEntry = this;
 		if (fs.root && parent && parent.getChildByName(name)) {
-			throw new Error("Entry filename already exists");
+			throw new Error(ERR_ENTRY_EXISTS);
 		}
 		if (!params) {
 			params = {};
@@ -69,13 +72,17 @@ class ZipEntry {
 			name,
 			data: params.data,
 			options: params.options,
-			id: fs.entries.length,
+			id: fs.entryIdCounter++,
 			parent,
 			children: [],
 			uncompressedSize: params.uncompressedSize || 0,
 			passThrough: params.passThrough
 		});
-		fs.entries.push(zipEntry);
+		// detached entries (e.g. clones) are not registered until they are attached,
+		// otherwise they could never be garbage collected
+		if (parent || !fs.root) {
+			fs.entries[zipEntry.id] = zipEntry;
+		}
 		if (parent) {
 			zipEntry.parent.children.push(zipEntry);
 		}
@@ -113,7 +120,7 @@ class ZipEntry {
 	rename(name) {
 		const parent = this.parent;
 		if (parent && parent.getChildByName(name)) {
-			throw new Error("Entry filename already exists");
+			throw new Error(ERR_ENTRY_EXISTS);
 		} else {
 			this.name = name;
 		}
@@ -152,16 +159,17 @@ class ZipFileEntry extends ZipEntry {
 	}
 
 	isPasswordProtected() {
-		return this.data.encrypted;
+		return Boolean(this.data && this.data.encrypted);
 	}
 
 	async checkPassword(password, options = {}) {
 		const zipEntry = this;
 		if (zipEntry.isPasswordProtected()) {
-			options.password = password;
-			options.checkPasswordOnly = true;
 			try {
-				await zipEntry.data.getData(null, options);
+				await zipEntry.data.getData(null, Object.assign({}, options, {
+					password,
+					checkPasswordOnly: true
+				}));
 				return true;
 			} catch (error) {
 				if (error.message == ERR_INVALID_PASSWORD) {
@@ -195,8 +203,15 @@ class ZipFileEntry extends ZipEntry {
 		return this.getData({ writable }, options);
 	}
 
-	getArrayBuffer(options) {
-		return this.data.arrayBuffer(options);
+	async getArrayBuffer(options) {
+		// this.data may be a string, a Uint8Array, a data URI or a Blob depending on how the entry
+		// was created, so retrieve the bytes through getUint8Array rather than assuming a Blob; this
+		// also applies the options (password, signal, onprogress...) like the other getData() getters
+		const array = await this.getUint8Array(options);
+		// return the backing buffer directly when the array spans it, slicing the exact bytes otherwise
+		return array.byteOffset || array.byteLength != array.buffer.byteLength
+			? array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength)
+			: array.buffer;
 	}
 
 	replaceBlob(blob) {
@@ -238,7 +253,7 @@ class ZipFileEntry extends ZipEntry {
 	replaceReadable(readable) {
 		Object.assign(this, {
 			data: null,
-			Reader: function () { return { readable }; },
+			Reader: getReadableReader(readable),
 			Writer: null,
 			reader: null
 		});
@@ -254,7 +269,7 @@ class ZipDirectoryEntry extends ZipEntry {
 
 	clone(deepClone) {
 		const zipEntry = this;
-		const clonedEntry = new ZipDirectoryEntry(zipEntry.fs, zipEntry.name);
+		const clonedEntry = new ZipDirectoryEntry(zipEntry.fs, zipEntry.name, zipEntry);
 		if (deepClone) {
 			clonedEntry.children = zipEntry.children.map(child => {
 				const childClone = child.clone(deepClone);
@@ -328,7 +343,7 @@ class ZipDirectoryEntry extends ZipEntry {
 
 	addReadable(name, readable, options = {}) {
 		return addChild(this, name, {
-			Reader: function () { return { readable }; },
+			Reader: getReadableReader(readable),
 			options
 		});
 	}
@@ -342,6 +357,7 @@ class ZipDirectoryEntry extends ZipEntry {
 	}
 
 	addFile(file, options = {}) {
+		options = Object.assign({}, options);
 		if (!options.lastModDate) {
 			options.lastModDate = new Date(file.lastModified);
 		}
@@ -408,11 +424,15 @@ class ZipDirectoryEntry extends ZipEntry {
 			try {
 				const path = entry.filename.split("/");
 				const name = path.pop();
-				path.forEach((pathPart, pathIndex) => {
+				path.forEach(pathPart => {
 					const previousParent = parent;
 					parent = parent.getChildByName(pathPart);
-					if (!parent) {
-						parent = new ZipDirectoryEntry(this.fs, pathPart, { data: pathIndex == path.length - 1 ? entry : null }, previousParent);
+					if (parent) {
+						if (!parent.directory) {
+							throw new Error(ERR_ENTRY_EXISTS);
+						}
+					} else {
+						parent = new ZipDirectoryEntry(this.fs, pathPart, { data: null }, previousParent);
 						importedEntries.push(parent);
 					}
 				});
@@ -423,6 +443,22 @@ class ZipDirectoryEntry extends ZipEntry {
 						uncompressedSize: entry.uncompressedSize,
 						passThrough: options.passThrough
 					}));
+				} else {
+					let directoryEntry = parent;
+					if (name) {
+						directoryEntry = parent.getChildByName(name);
+						if (directoryEntry) {
+							if (!directoryEntry.directory) {
+								throw new Error(ERR_ENTRY_EXISTS);
+							}
+						} else {
+							directoryEntry = new ZipDirectoryEntry(this.fs, name, { data: null }, parent);
+							importedEntries.push(directoryEntry);
+						}
+					}
+					if (directoryEntry != this && !directoryEntry.data) {
+						directoryEntry.data = entry;
+					}
 				}
 			} catch (error) {
 				try {
@@ -438,14 +474,15 @@ class ZipDirectoryEntry extends ZipEntry {
 		return importedEntries;
 	}
 
-	async exportZip(writer, options) {
+	async exportZip(writer, options = {}) {
 		const zipEntry = this;
+		options = Object.assign({}, options);
 		if (options.bufferedWrite === UNDEFINED_VALUE) {
 			options.bufferedWrite = true;
 		}
-		await Promise.all([initReaders(zipEntry, options.readerOptions), initStream(writer)]);
+		const [readers] = await Promise.all([initReaders(zipEntry, options.readerOptions), initStream(writer)]);
 		const zipWriter = new ZipWriter(writer, options);
-		await exportZip(zipWriter, zipEntry, getTotalSize([zipEntry], "uncompressedSize"), options);
+		await exportZip(zipWriter, zipEntry, getTotalSize([zipEntry], "uncompressedSize"), options, readers);
 		await zipWriter.close();
 		return writer.getData ? writer.getData() : writer.writable;
 	}
@@ -491,7 +528,15 @@ class FS {
 
 	remove(entry) {
 		detach(entry);
-		this.entries[entry.id] = null;
+		const removedEntries = [entry];
+		while (removedEntries.length) {
+			const removedEntry = removedEntries.pop();
+			this.entries[removedEntry.id] = null;
+			for (const child of removedEntry.children) {
+				removedEntries.push(child);
+			}
+		}
+		entry.parent = UNDEFINED_VALUE;
 	}
 
 	move(entry, destination) {
@@ -501,12 +546,17 @@ class FS {
 			if (destination.directory) {
 				if (!destination.isDescendantOf(entry)) {
 					if (entry != destination) {
-						if (destination.getChildByName(entry.name)) {
-							throw new Error("Entry filename already exists");
+						const existingChild = destination.getChildByName(entry.name);
+						if (existingChild) {
+							if (existingChild != entry) {
+								throw new Error(ERR_ENTRY_EXISTS);
+							}
+						} else {
+							detach(entry);
+							entry.parent = destination;
+							destination.children.push(entry);
+							registerEntries(this, entry);
 						}
-						detach(entry);
-						entry.parent = destination;
-						destination.children.push(entry);
 					}
 				} else {
 					throw new Error("Entry is a ancestor of target entry");
@@ -523,6 +573,11 @@ class FS {
 		for (let index = 0; node && index < path.length; index++) {
 			node = node.getChildByName(path[index]);
 		}
+		if (!node) {
+			// exclude detached entries, e.g. clones registered in `entries` but not attached
+			node = this.entries.find(entry => entry && (entry == this.root || entry.isDescendantOf(this.root)) &&
+				entry.getRelativeName() == fullname);
+		}
 		return node;
 	}
 
@@ -604,6 +659,7 @@ class FS {
 	}
 
 	importZip(reader, options) {
+		resetFS(this);
 		return this.root.importZip(reader, options);
 	}
 
@@ -623,6 +679,10 @@ class FS {
 		return this.root.exportWritable(writable, options);
 	}
 
+	exportZip(writer, options) {
+		return this.root.exportZip(writer, options);
+	}
+
 	isPasswordProtected() {
 		return this.root.isPasswordProtected();
 	}
@@ -637,15 +697,26 @@ export { fs };
 
 function getTotalSize(entries, propertyName) {
 	let size = 0;
-	entries.forEach(process);
+	const pendingEntries = Array.from(entries);
+	while (pendingEntries.length) {
+		const entry = pendingEntries.pop();
+		size += entry[propertyName] || 0;
+		for (const child of entry.children) {
+			pendingEntries.push(child);
+		}
+	}
 	return size;
+}
 
-	function process(entry) {
-		size += entry[propertyName];
-		if (entry.children) {
-			entry.children.forEach(process);
+function getReadableReader(readable) {
+	let consumed;
+	return function () {
+		if (consumed) {
+			throw new Error(ERR_READABLE_CONSUMED);
 		}
-	}
+		consumed = true;
+		return { readable };
+	};
 }
 
 function getZipBlobReader(options) {
@@ -660,7 +731,7 @@ function getZipBlobReader(options) {
 		async init() {
 			const zipBlobReader = this;
 			zipBlobReader.size = zipBlobReader.entry.uncompressedSize;
-			const data = await zipBlobReader.entry.getData(new BlobWriter(), Object.assign({}, zipBlobReader.options, options));
+			const data = await zipBlobReader.entry.getData(new BlobWriter(), Object.assign({}, options, zipBlobReader.options));
 			zipBlobReader.data = data;
 			zipBlobReader.blobReader = new BlobReader(data);
 			super.init();
@@ -673,29 +744,41 @@ function getZipBlobReader(options) {
 }
 
 async function initReaders(entry, options) {
-	if (entry.children.length) {
-		await Promise.all(entry.children.map(async child => {
+	const fileEntries = [];
+	const pendingEntries = [entry];
+	// per-export map so concurrent exports do not share (and lock) the same readers
+	const readers = new Map();
+	while (pendingEntries.length) {
+		const pendingEntry = pendingEntries.pop();
+		for (const child of pendingEntry.children) {
 			if (child.directory) {
-				await initReaders(child, options);
+				pendingEntries.push(child);
 			} else {
-				const reader = child.reader = new child.Reader(child.data, options);
-				try {
-					await initStream(reader);
-				} catch (error) {
-					try {
-						error.entryId = child.id;
-						error.cause = {
-							entry: child
-						};
-					} catch {
-						// ignored
-					}
-					throw error;
-				}
-				child.uncompressedSize = reader.size;
+				fileEntries.push(child);
 			}
-		}));
+		}
 	}
+	await Promise.all(fileEntries.map(async child => {
+		const reader = child.reader = new child.Reader(child.data, options);
+		readers.set(child, reader);
+		try {
+			await initStream(reader);
+		} catch (error) {
+			try {
+				error.entryId = child.id;
+				error.cause = {
+					entry: child
+				};
+			} catch {
+				// ignored
+			}
+			throw error;
+		}
+		if (reader.size !== UNDEFINED_VALUE) {
+			child.uncompressedSize = reader.size;
+		}
+	}));
+	return readers;
 }
 
 function detach(entry) {
@@ -709,7 +792,7 @@ function detach(entry) {
 	}
 }
 
-async function exportZip(zipWriter, entry, totalSize, options) {
+async function exportZip(zipWriter, entry, totalSize, options, readers) {
 	const selectedEntry = entry;
 	const entryOffsets = new Map();
 	await process(zipWriter, entry);
@@ -719,7 +802,11 @@ async function exportZip(zipWriter, entry, totalSize, options) {
 
 		async function exportChild() {
 			if (options.bufferedWrite) {
-				await Promise.allSettled(entry.children.map(processChild));
+				const results = await Promise.allSettled(entry.children.map(processChild));
+				const errorResult = results.find(result => result.status == "rejected");
+				if (errorResult) {
+					throw errorResult.reason;
+				}
 			} else {
 				for (const child of entry.children) {
 					await processChild(child);
@@ -774,7 +861,7 @@ async function exportZip(zipWriter, entry, totalSize, options) {
 					});
 				}
 			}
-			await zipWriter.add(name, child.reader, Object.assign({}, options, zipEntryOptions, childOptions, {
+			await zipWriter.add(name, readers.get(child), Object.assign({}, options, zipEntryOptions, childOptions, {
 				directory: child.directory,
 				onprogress: async indexProgress => {
 					if (options.onprogress) {
@@ -823,7 +910,7 @@ function addFileSystemHandle(zipEntry, handle, options) {
 				}
 			} catch (error) {
 				const message = error.message + (handle ? " (" + handle.name + ")" : "");
-				throw new Error(message);
+				throw new Error(message, { cause: error });
 			}
 		}
 		return addedEntries;
@@ -883,9 +970,21 @@ async function transformToFileSystemhandles(entry) {
 
 function resetFS(fs) {
 	fs.entries = [];
+	fs.entryIdCounter = 0;
 	fs.root = new ZipDirectoryEntry(fs);
 }
 
+function registerEntries(fs, entry) {
+	const pendingEntries = [entry];
+	while (pendingEntries.length) {
+		const pendingEntry = pendingEntries.pop();
+		fs.entries[pendingEntry.id] = pendingEntry;
+		for (const child of pendingEntry.children) {
+			pendingEntries.push(child);
+		}
+	}
+}
+
 function addChild(parent, name, params, directory) {
 	if (parent.directory) {
 		return directory ? new ZipDirectoryEntry(parent.fs, name, params, parent) : new ZipFileEntry(parent.fs, name, params, parent);