@clearmist-labs/comic-archive-handler 1.5.0 → 1.7.0

package/dist/index.d.mts

@@ -30,6 +30,12 @@ export interface ImageConvertOptions {
   jpeg?: JpegOptions;
   png?: PngOptions;
 }
+/**
+ * How many images an archive operation converts at once. A function is called
+ * again before each conversion starts, so the limit can change while an archive
+ * is being processed. Values below 1 are treated as 1.
+ */
+export type ImageConcurrency = number | (() => number);
 /** Shared by every archive-producing operation. */
 export interface ArchiveWriteOptions {
   /**
@@ -49,6 +55,8 @@ export interface ConvertArchiveOptions extends ArchiveWriteOptions {
   image?: {
     format: ImageOutputFormat;
     options?: ImageConvertOptions;
+    /** How many images to convert at once. Defaults to `1`. */
+    concurrency?: ImageConcurrency;
   };
   /**
    * Replaces the source's embedded comic metadata in the output. The source's
@@ -469,7 +477,21 @@ export declare function removeComicMetadata(input: ArchiveInput, schema: Metadat
 //#endregion
 //#region src/images/convert.d.ts
 export declare function convertImageBuffer(image: Buffer, format: ImageOutputFormat, options?: ImageConvertOptions): Promise<Buffer>;
-export declare function convertArchiveImages(input: ArchiveInput, format: ImageOutputFormat, options?: ImageConvertOptions & ArchiveWriteOptions): Promise<Buffer | void>;
+export declare function convertArchiveImages(input: ArchiveInput, format: ImageOutputFormat, options?: ImageConvertOptions & ArchiveWriteOptions & {
+  concurrency?: ImageConcurrency;
+}): Promise<Buffer | void>;
+//#endregion
+//#region src/images/concurrency.d.ts
+/**
+ * Sets how many libvips threads process each image, and returns the value now
+ * in effect. The setting is process-wide and applies to every image operation
+ * this package performs (conversion, dimensions, perceptual hashing). Callers
+ * that already parallelize across images (one worker thread per core, say)
+ * should pass `1` so each image doesn't also fan out across every core.
+ * sharp's default is the CPU core count, except on glibc Linux without
+ * jemalloc, where it is already `1`.
+ */
+export declare function setImageConcurrency(threads: number): number;
 //#endregion
 //#region src/images/phash.d.ts
 /**
@@ -489,7 +511,13 @@ export interface ImageDimensions {
   width: number;
   height: number;
 }
-/** Reads an image's pixel dimensions from its header without decoding it; `null` when the buffer isn't an image `sharp` can read. */
+export interface ImageInfo extends ImageDimensions {
+  /** The format detected from the image's contents (not its file extension), such as `jpeg`, `png`, `webp`, or `bmp`. */
+  type: string;
+}
+/** Reads an image's format and pixel dimensions from its header without decoding it; `null` when the buffer isn't a readable image. */
+export declare function readImageInfo(buffer: Buffer): Promise<ImageInfo | null>;
+/** Reads an image's pixel dimensions from its header without decoding it; `null` when the buffer isn't a readable image. */
 export declare function readImageDimensions(buffer: Buffer): Promise<ImageDimensions | null>;
 //#endregion
 //#region src/images/isImage.d.ts
@@ -552,6 +580,27 @@ export interface ReadArchiveEntriesResult {
  */
 export declare function readArchiveEntries(input: ArchiveInput): AsyncGenerator<ReadArchiveEntriesResult>;
 //#endregion
+//#region src/readArchiveImageInfo.d.ts
+export interface ArchiveImageInfo {
+  /** The entry's file name, without its directory. */
+  name: string;
+  /** The entry's full path inside the archive. */
+  path: string;
+  /** Pixel width, or `null` when the entry's contents aren't a readable image. */
+  width: number | null;
+  /** Pixel height, or `null` when the entry's contents aren't a readable image. */
+  height: number | null;
+  /** The format detected from the entry's contents (not its extension), or `null` when the contents aren't a readable image. */
+  type: string | null;
+}
+/**
+ * Returns the name, path, dimensions, and format of every image entry in an
+ * archive, in archive iteration order. Image entries are identified by
+ * extension (see `isImagePath`); non-image entries are skipped without being
+ * read. Everything is gathered in a single pass over the archive.
+ */
+export declare function readArchiveImageInfo(input: ArchiveInput): Promise<ArchiveImageInfo[]>;
+//#endregion
 //#region src/removeArchiveEntry.d.ts
 export declare function removeArchiveEntry(input: ArchiveInput, entryPath: string, options?: RemoveEntryOptions): Promise<Buffer | void>;
 //#endregion
@@ -582,12 +631,15 @@ export declare function renderBenchmarkReportMarkdown(result: BenchmarkArchiveRe
 declare const comicArchiveHandler: {
   convertImageBuffer: typeof convertImageBuffer;
   convertArchiveImages: typeof convertArchiveImages;
+  setImageConcurrency: typeof setImageConcurrency;
   computeImagePHash: typeof computeImagePHash;
   phashToHex: typeof phashToHex;
   computeArchiveImagePHash: typeof computeArchiveImagePHash;
   hammingDistance: typeof hammingDistance;
   IMAGE_EXTENSIONS: readonly ["jpg", "jpeg", "png", "gif", "webp", "bmp", "tiff", "tif"];
   isImagePath: typeof isImagePath;
+  readImageDimensions: typeof readImageDimensions;
+  readImageInfo: typeof readImageInfo;
   sha256ArchiveEntry: typeof sha256ArchiveEntry;
   sha256Archive: typeof sha256Archive;
   renameArchiveImagesSequentially: typeof renameArchiveImagesSequentially;
@@ -595,6 +647,7 @@ declare const comicArchiveHandler: {
   listArchiveFiles: typeof listArchiveFiles;
   readArchiveEntry: typeof readArchiveEntry;
   readArchiveEntries: typeof readArchiveEntries;
+  readArchiveImageInfo: typeof readArchiveImageInfo;
   removeArchiveEntry: typeof removeArchiveEntry;
   benchmarkArchive: typeof benchmarkArchive;
   renderBenchmarkReportMarkdown: typeof renderBenchmarkReportMarkdown;

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/benchmark/types.ts","../src/errors.ts","../src/detect.ts","../src/convertArchive.ts","../src/extractArchive.ts","../src/metadata/comicInfo.ts","../src/metadata/metronInfo.ts","../src/metadata/validate.ts","../src/metadata/schema.ts","../src/metadata/index.ts","../src/images/convert.ts","../src/images/phash.ts","../src/images/dimensions.ts","../src/images/isImage.ts","../src/hashing/sha256.ts","../src/rename.ts","../src/strip.ts","../src/listFiles.ts","../src/readArchiveEntry.ts","../src/readArchiveEntries.ts","../src/removeArchiveEntry.ts","../src/benchmark/benchmarkArchive.ts","../src/benchmark/report.ts","../src/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/benchmark/types.ts","../src/errors.ts","../src/detect.ts","../src/convertArchive.ts","../src/extractArchive.ts","../src/metadata/comicInfo.ts","../src/metadata/metronInfo.ts","../src/metadata/validate.ts","../src/metadata/schema.ts","../src/metadata/index.ts","../src/images/convert.ts","../src/images/concurrency.ts","../src/images/phash.ts","../src/images/dimensions.ts","../src/images/isImage.ts","../src/hashing/sha256.ts","../src/rename.ts","../src/strip.ts","../src/listFiles.ts","../src/readArchiveEntry.ts","../src/readArchiveEntries.ts","../src/readArchiveImageInfo.ts","../src/removeArchiveEntry.ts","../src/benchmark/benchmarkArchive.ts","../src/benchmark/report.ts","../src/index.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -814,6 +814,43 @@ function getAdapter(type) {
 	return adapter;
 }
 //#endregion
+//#region src/internal/convertEntriesConcurrently.ts
+function resolveLimit(concurrency) {
+	const value = typeof concurrency === "function" ? concurrency() : concurrency;
+	return Number.isFinite(value) ? Math.max(1, Math.floor(value)) : 1;
+}
+/**
+* Maps source entries to write entries, running up to `concurrency` image
+* conversions at once while preserving entry order. Each image's bytes are
+* read before the source iterator advances, so adapters whose entry streams
+* are only valid until the next entry keep working. A pass-through entry is
+* yielded only after every earlier conversion has been yielded, and before the
+* source advances, since its content is read lazily by the writer. A function
+* `concurrency` is re-read before each new conversion starts, so the limit can
+* follow the caller's load while the archive is being converted.
+*/
+async function* convertEntriesConcurrently(source, shouldConvert, convert, passThrough, concurrency = 1) {
+	const pending = [];
+	try {
+		for await (const entry of source) {
+			if (shouldConvert(entry)) {
+				const task = convert(entry, await streamToBuffer(entry.openReadStream()));
+				task.catch(() => void 0);
+				pending.push(task);
+				while (pending.length >= resolveLimit(concurrency)) yield await pending.shift();
+				continue;
+			}
+			const output = passThrough(entry);
+			if (!output) continue;
+			while (pending.length > 0) yield await pending.shift();
+			yield output;
+		}
+		while (pending.length > 0) yield await pending.shift();
+	} finally {
+		await Promise.allSettled(pending);
+	}
+}
+//#endregion
 //#region src/images/isImage.ts
 const IMAGE_EXTENSIONS = [
 	"jpg",
@@ -862,22 +899,20 @@ function replaceExtension$1(entryPath, format) {
 }
 async function convertArchiveImages(input, format, options = {}) {
 	const adapter = getAdapter(await detectArchiveType(input));
-	const { tempDir, output, ...imageOptions } = options;
-	async function* entries() {
-		for await (const entry of adapter.listEntries(input, { tempDir })) if (isImagePath(entry.path) && getExtension(entry.path) !== (format === "jpg" ? "jpg" : format)) {
-			const converted = await convertImageBuffer(await streamToBuffer(entry.openReadStream()), format, imageOptions);
-			yield {
-				path: replaceExtension$1(entry.path, format),
-				size: converted.length,
-				content: Readable.from(converted)
-			};
-		} else yield {
-			path: entry.path,
-			size: entry.size,
-			content: entry.openReadStream()
+	const { tempDir, output, concurrency, ...imageOptions } = options;
+	const entries = convertEntriesConcurrently(adapter.listEntries(input, { tempDir }), (entry) => isImagePath(entry.path) && getExtension(entry.path) !== (format === "jpg" ? "jpg" : format), async (entry, buffer) => {
+		const converted = await convertImageBuffer(buffer, format, imageOptions);
+		return {
+			path: replaceExtension$1(entry.path, format),
+			size: converted.length,
+			content: Readable.from(converted)
 		};
-	}
-	return withOutput(output, (destination) => adapter.write(entries(), destination, { tempDir }));
+	}, (entry) => ({
+		path: entry.path,
+		size: entry.size,
+		content: entry.openReadStream()
+	}), concurrency);
+	return withOutput(output, (destination) => adapter.write(entries, destination, { tempDir }));
 }
 //#endregion
 //#region src/removeArchiveEntry.ts
@@ -1900,21 +1935,19 @@ async function convertArchive(input, targetType, options = {}) {
 	const image = options.image;
 	const metadata = options.metadata;
 	async function* entries() {
-		for await (const entry of sourceAdapter.listEntries(input, { tempDir: options.tempDir })) {
-			if (metadata && METADATA_FILE_NAMES.has(entry.path.split("/").pop() ?? "")) continue;
-			if (image && isImagePath(entry.path) && getExtension(entry.path) !== (image.format === "jpg" ? "jpg" : image.format)) {
-				const converted = await convertImageBuffer(await streamToBuffer(entry.openReadStream()), image.format, image.options);
-				yield {
-					path: replaceExtension(entry.path, image.format === "jpg" ? "jpg" : image.format),
-					size: converted.length,
-					content: Readable.from(converted)
-				};
-			} else yield {
-				path: entry.path,
-				size: entry.size,
-				content: entry.openReadStream()
+		const imageExtension = image?.format === "jpg" ? "jpg" : image?.format;
+		yield* convertEntriesConcurrently(sourceAdapter.listEntries(input, { tempDir: options.tempDir }), (entry) => Boolean(image) && isImagePath(entry.path) && getExtension(entry.path) !== imageExtension, async (entry, buffer) => {
+			const converted = await convertImageBuffer(buffer, image.format, image.options);
+			return {
+				path: replaceExtension(entry.path, imageExtension),
+				size: converted.length,
+				content: Readable.from(converted)
 			};
-		}
+		}, (entry) => metadata && METADATA_FILE_NAMES.has(entry.path.split("/").pop() ?? "") ? void 0 : {
+			path: entry.path,
+			size: entry.size,
+			content: entry.openReadStream()
+		}, image?.concurrency);
 		if (metadata && targetType !== "asar") for (const schema of Object.keys(metadata)) {
 			const value = metadata[schema];
 			if (!value) continue;
@@ -1953,6 +1986,20 @@ async function extractArchive(input, destDir, options = {}) {
 	return written;
 }
 //#endregion
+//#region src/images/concurrency.ts
+/**
+* Sets how many libvips threads process each image, and returns the value now
+* in effect. The setting is process-wide and applies to every image operation
+* this package performs (conversion, dimensions, perceptual hashing). Callers
+* that already parallelize across images (one worker thread per core, say)
+* should pass `1` so each image doesn't also fan out across every core.
+* sharp's default is the CPU core count, except on glibc Linux without
+* jemalloc, where it is already `1`.
+*/
+function setImageConcurrency(threads) {
+	return sharp.concurrency(threads);
+}
+//#endregion
 //#region src/images/phash.ts
 const HASH_SIZE = 32;
 const BLOCK_SIZE = 8;
@@ -2023,18 +2070,39 @@ async function computeArchiveImagePHash(input, entryPath) {
 }
 //#endregion
 //#region src/images/dimensions.ts
-/** Reads an image's pixel dimensions from its header without decoding it; `null` when the buffer isn't an image `sharp` can read. */
-async function readImageDimensions(buffer) {
+const BMP_HEADER_SIZE = 26;
+/** `sharp` can't read BMP, so read a BMP's dimensions straight from its `BITMAPINFOHEADER`. Height is negative for top-down bitmaps. */
+function readBmpInfo(buffer) {
+	if (buffer.length < BMP_HEADER_SIZE || buffer.toString("latin1", 0, 2) !== "BM") return null;
+	const width = buffer.readInt32LE(18);
+	const height = Math.abs(buffer.readInt32LE(22));
+	return width > 0 && height > 0 ? {
+		width,
+		height,
+		type: "bmp"
+	} : null;
+}
+/** Reads an image's format and pixel dimensions from its header without decoding it; `null` when the buffer isn't a readable image. */
+async function readImageInfo(buffer) {
 	try {
-		const { width, height } = await sharp(buffer).metadata();
+		const { width, height, format } = await sharp(buffer).metadata();
 		return width !== void 0 && height !== void 0 ? {
 			width,
-			height
+			height,
+			type: format
 		} : null;
 	} catch {
-		return null;
+		return readBmpInfo(buffer);
 	}
 }
+/** Reads an image's pixel dimensions from its header without decoding it; `null` when the buffer isn't a readable image. */
+async function readImageDimensions(buffer) {
+	const info = await readImageInfo(buffer);
+	return info ? {
+		width: info.width,
+		height: info.height
+	} : null;
+}
 //#endregion
 //#region src/hashing/asarContent.ts
 /**
@@ -2190,6 +2258,30 @@ async function* readArchiveEntries(input) {
 	}
 }
 //#endregion
+//#region src/readArchiveImageInfo.ts
+/**
+* Returns the name, path, dimensions, and format of every image entry in an
+* archive, in archive iteration order. Image entries are identified by
+* extension (see `isImagePath`); non-image entries are skipped without being
+* read. Everything is gathered in a single pass over the archive.
+*/
+async function readArchiveImageInfo(input) {
+	const adapter = getAdapter(await detectArchiveType(input));
+	const images = [];
+	for await (const entry of adapter.listEntries(input)) {
+		if (!isImagePath(entry.path)) continue;
+		const info = await readImageInfo(await streamToBuffer(entry.openReadStream()));
+		images.push({
+			name: path.posix.basename(entry.path.replaceAll("\\", "/")),
+			path: entry.path,
+			width: info?.width ?? null,
+			height: info?.height ?? null,
+			type: info?.type ?? null
+		});
+	}
+	return images;
+}
+//#endregion
 //#region src/benchmark/timing.ts
 /** Runs `run` `iterations` times and returns the average duration in milliseconds. */
 async function averageDuration(iterations, run) {
@@ -2422,12 +2514,15 @@ const comicArchiveHandler = {
 	...metadata_exports,
 	convertImageBuffer,
 	convertArchiveImages,
+	setImageConcurrency,
 	computeImagePHash,
 	phashToHex,
 	computeArchiveImagePHash,
 	hammingDistance,
 	IMAGE_EXTENSIONS,
 	isImagePath,
+	readImageDimensions,
+	readImageInfo,
 	sha256ArchiveEntry,
 	sha256Archive,
 	renameArchiveImagesSequentially,
@@ -2435,6 +2530,7 @@ const comicArchiveHandler = {
 	listArchiveFiles,
 	readArchiveEntry,
 	readArchiveEntries,
+	readArchiveImageInfo,
 	removeArchiveEntry,
 	benchmarkArchive,
 	renderBenchmarkReportMarkdown,
@@ -2443,6 +2539,6 @@ const comicArchiveHandler = {
 	ARCHIVE_TYPE_EXTENSIONS
 };
 //#endregion
-export { ARCHIVE_TYPE_EXTENSIONS, ArchiveFormatError, BENCHMARK_IMAGE_FORMATS, COMIC_INFO_AGE_RATING_VALUES, COMIC_INFO_CREDIT_ROLES, COMIC_INFO_MANGA_VALUES, COMIC_INFO_PAGE_TYPE_VALUES, COMIC_INFO_YES_NO_VALUES, FilesystemAccessError, IMAGE_EXTENSIONS, METRON_AGE_RATING_VALUES, METRON_FORMAT_VALUES, METRON_INFORMATION_SOURCE_VALUES, METRON_ROLE_VALUES, MetadataNotFoundError, NoImagesFoundError, SevenZipUnavailableError, UnsupportedOperationError, WRITABLE_ARCHIVE_TYPES, addMetadataToArchive, benchmarkArchive, comicInfoXmlToMetadata, computeArchiveImagePHash, computeImagePHash, convertArchive, convertArchiveImages, convertImageBuffer, comicArchiveHandler as default, detectArchiveType, extractArchive, getExtension, hammingDistance, hasComicMetadata, is7z, isAce, isAsar, isImagePath, isRar, isTar, isZip, joinCommaList, joinResourceNames, listArchiveFiles, metadataToComicInfoXml, metadataToMetronInfoXml, metadataToXml, metronInfoXmlToMetadata, phashToHex, readArchiveEntries, readArchiveEntry, readArchiveMetadata, readImageDimensions, removeArchiveEntry, removeComicMetadata, renameArchiveImagesSequentially, renderBenchmarkReportMarkdown, resourceId, resourceName, sha256Archive, sha256ArchiveEntry, splitCommaList, stripNonEssentialFiles, validateMetadataXml, xmlToMetadata };
+export { ARCHIVE_TYPE_EXTENSIONS, ArchiveFormatError, BENCHMARK_IMAGE_FORMATS, COMIC_INFO_AGE_RATING_VALUES, COMIC_INFO_CREDIT_ROLES, COMIC_INFO_MANGA_VALUES, COMIC_INFO_PAGE_TYPE_VALUES, COMIC_INFO_YES_NO_VALUES, FilesystemAccessError, IMAGE_EXTENSIONS, METRON_AGE_RATING_VALUES, METRON_FORMAT_VALUES, METRON_INFORMATION_SOURCE_VALUES, METRON_ROLE_VALUES, MetadataNotFoundError, NoImagesFoundError, SevenZipUnavailableError, UnsupportedOperationError, WRITABLE_ARCHIVE_TYPES, addMetadataToArchive, benchmarkArchive, comicInfoXmlToMetadata, computeArchiveImagePHash, computeImagePHash, convertArchive, convertArchiveImages, convertImageBuffer, comicArchiveHandler as default, detectArchiveType, extractArchive, getExtension, hammingDistance, hasComicMetadata, is7z, isAce, isAsar, isImagePath, isRar, isTar, isZip, joinCommaList, joinResourceNames, listArchiveFiles, metadataToComicInfoXml, metadataToMetronInfoXml, metadataToXml, metronInfoXmlToMetadata, phashToHex, readArchiveEntries, readArchiveEntry, readArchiveImageInfo, readArchiveMetadata, readImageDimensions, readImageInfo, removeArchiveEntry, removeComicMetadata, renameArchiveImagesSequentially, renderBenchmarkReportMarkdown, resourceId, resourceName, setImageConcurrency, sha256Archive, sha256ArchiveEntry, splitCommaList, stripNonEssentialFiles, validateMetadataXml, xmlToMetadata };
 
 //# sourceMappingURL=index.mjs.map