nbis-wrapper-js 0.0.1 → 0.2.0

package/dist/src/cjpegl.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type CjpeglOptions = {
     rawIn?: {
         width: number;
@@ -18,7 +19,14 @@ export type CjpeglResult = {
     stdout: string;
     stderr: string;
 };
+export type CjpeglStreamOptions = CjpeglOptions & StreamIoOptions;
+export type CjpeglStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Cjpegl {
     version(): string;
     compress(outputExtension: string, imagePath: string, options?: CjpeglOptions): CjpeglResult;
+    compressStream(outputExtension: string, input: StreamInput, options?: CjpeglStreamOptions): Promise<CjpeglStreamResult>;
 }

package/dist/src/cjpegl.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cjpegl = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function buildRawAttr(raw) {
     const attrs = [raw.width, raw.height, raw.depth];
     if (raw.ppi != null) {
@@ -50,5 +51,32 @@ class Cjpegl {
             stderr: result.stderr
         };
     }
+    async compressStream(outputExtension, input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [outputExtension, inputPath];
+            if (options.rawIn) {
+                args.push('-raw_in', buildRawAttr(options.rawIn));
+            }
+            if (options.nonInterleaved) {
+                args.push('-nonintrlv');
+            }
+            if (options.yCbCr) {
+                args.push('-YCbCr', buildYCbCr(options.yCbCr));
+            }
+            if (options.commentFile) {
+                args.push(options.commentFile);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('cjpegl', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'cjpegl');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Cjpegl = Cjpegl;

package/dist/src/cwsq.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type CwsqOptions = {
     rawIn?: {
         width: number;
@@ -12,7 +13,14 @@ export type CwsqResult = {
     stdout: string;
     stderr: string;
 };
+export type CwsqStreamOptions = CwsqOptions & StreamIoOptions;
+export type CwsqStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Cwsq {
     version(): string;
     compress(bitrate: number, outputExtension: string, imagePath: string, options?: CwsqOptions): CwsqResult;
+    compressStream(bitrate: number, outputExtension: string, input: StreamInput, options?: CwsqStreamOptions): Promise<CwsqStreamResult>;
 }

package/dist/src/cwsq.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cwsq = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function buildRawAttr(raw) {
     const attrs = [raw.width, raw.height, raw.depth];
     if (raw.ppi != null) {
@@ -40,5 +41,26 @@ class Cwsq {
             stderr: result.stderr
         };
     }
+    async compressStream(bitrate, outputExtension, input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [String(bitrate), outputExtension, inputPath];
+            if (options.rawIn) {
+                args.push('-raw_in', buildRawAttr(options.rawIn));
+            }
+            if (options.commentFile) {
+                args.push(options.commentFile);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('cwsq', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'cwsq');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Cwsq = Cwsq;

package/dist/src/datainfo.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamInputOptions } from './temp-io';
 export type DatainfoResult = {
     stdout: string;
     stderr: string;
@@ -5,4 +6,5 @@ export type DatainfoResult = {
 export declare class Datainfo {
     version(): string;
     report(dataFile: string): DatainfoResult;
+    reportStream(input: StreamInput, options?: StreamInputOptions): Promise<DatainfoResult>;
 }

package/dist/src/datainfo.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Datainfo = void 0;
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Datainfo {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('datainfo', ['-version']);
@@ -16,5 +17,16 @@ class Datainfo {
             stderr: result.stderr
         };
     }
+    async reportStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const dataFile = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const result = (0, nbis_runtime_1.runNbis)('datainfo', [dataFile]);
+            (0, nbis_runtime_1.assertSuccess)(result, 'datainfo');
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
+        });
+    }
 }
 exports.Datainfo = Datainfo;

package/dist/src/djp2k.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type Djp2kOptions = {
     inputPath?: string;
     outputPath?: string;
@@ -14,7 +15,16 @@ export type Djp2kResult = {
     stdout: string;
     stderr: string;
 };
+export type Djp2kStreamOptions = Omit<Djp2kOptions, 'inputPath' | 'outputPath' | 'imageDir'> & StreamIoOptions & {
+    outputExtension?: string;
+};
+export type Djp2kStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Djp2k {
     version(): string;
     decompress(options: Djp2kOptions): Djp2kResult;
+    decompressStream(input: StreamInput, options?: Djp2kStreamOptions): Promise<Djp2kStreamResult>;
 }

package/dist/src/djp2k.js

@@ -1,7 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Djp2k = void 0;
+const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
+function normalizeExtension(extension) {
+    if (!extension) {
+        return '';
+    }
+    return extension.startsWith('.') ? extension : `.${extension}`;
+}
 class Djp2k {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('djp2k', ['-h']);
@@ -49,5 +60,46 @@ class Djp2k {
             stderr: result.stderr
         };
     }
+    async decompressStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const outputExtension = options.outputExtension || options.outputFormat;
+            if (!outputExtension) {
+                throw new Error('djp2k stream output requires outputExtension or outputFormat.');
+            }
+            const outputPath = path_1.default.join(tempDir, `output${normalizeExtension(outputExtension)}`);
+            const args = [];
+            if (options.outputFormat) {
+                args.push('-OutFor', options.outputFormat);
+            }
+            if (options.reduceFactor != null) {
+                args.push('-r', String(options.reduceFactor));
+            }
+            if (options.layers != null) {
+                args.push('-l', String(options.layers));
+            }
+            if (options.indexFile) {
+                args.push('-x', options.indexFile);
+            }
+            if (options.decodeArea) {
+                args.push('-d', options.decodeArea);
+            }
+            if (options.tileNumber != null) {
+                args.push('-t', String(options.tileNumber));
+            }
+            if (options.extraArgs) {
+                args.push(...options.extraArgs);
+            }
+            args.push('-i', inputPath, '-o', outputPath);
+            const result = (0, nbis_runtime_1.runNbis)('djp2k', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'djp2k');
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Djp2k = Djp2k;

package/dist/src/djpeg.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type DjpegOptions = {
     colors?: number;
     fast?: boolean;
@@ -20,6 +21,13 @@ export type DjpegResult = {
     stderr: string;
     outputPath?: string;
 };
+export type DjpegStreamOptions = Omit<DjpegOptions, 'outputPath'> & StreamIoOptions;
+export type DjpegStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Djpeg {
     decompress(inputPath: string, options?: DjpegOptions): DjpegResult;
+    decompressStream(input: StreamInput, options?: DjpegStreamOptions): Promise<DjpegStreamResult>;
 }

package/dist/src/djpeg.js

@@ -1,7 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Djpeg = void 0;
+const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Djpeg {
     decompress(inputPath, options = {}) {
         const args = [];
@@ -59,5 +64,64 @@ class Djpeg {
             outputPath: options.outputPath
         };
     }
+    async decompressStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const outputPath = path_1.default.join(tempDir, 'output');
+            const args = [];
+            if (options.colors != null) {
+                args.push('-colors', String(options.colors));
+            }
+            if (options.fast) {
+                args.push('-fast');
+            }
+            if (options.grayscale) {
+                args.push('-grayscale');
+            }
+            if (options.scale) {
+                args.push('-scale', options.scale);
+            }
+            if (options.format) {
+                args.push(`-${options.format}`);
+            }
+            if (options.dct) {
+                args.push('-dct', options.dct);
+            }
+            if (options.dither) {
+                args.push('-dither', options.dither);
+            }
+            if (options.mapFile) {
+                args.push('-map', options.mapFile);
+            }
+            if (options.noSmooth) {
+                args.push('-nosmooth');
+            }
+            if (options.onePass) {
+                args.push('-onepass');
+            }
+            if (options.maxMemory) {
+                args.push('-maxmemory', options.maxMemory);
+            }
+            args.push('-outfile', outputPath);
+            if (options.verbose) {
+                args.push('-verbose');
+            }
+            if (options.debug) {
+                args.push('-debug');
+            }
+            if (options.extraArgs) {
+                args.push(...options.extraArgs);
+            }
+            args.push(inputPath);
+            const result = (0, nbis_runtime_1.runNbis)('djpeg', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'djpeg');
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Djpeg = Djpeg;

package/dist/src/djpegb.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type DjpegbOptions = {
     rawOut?: boolean;
     nonInterleaved?: boolean;
@@ -8,7 +9,15 @@ export type DjpegbResult = {
     stdout: string;
     stderr: string;
 };
+export type DjpegbStreamOptions = DjpegbOptions & StreamIoOptions;
+export type DjpegbStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+    nistcomBuffer?: Buffer;
+};
 export declare class Djpegb {
     version(): string;
     decompress(outputExtension: string, imagePath: string, options?: DjpegbOptions): DjpegbResult;
+    decompressStream(outputExtension: string, input: StreamInput, options?: DjpegbStreamOptions): Promise<DjpegbStreamResult>;
 }

package/dist/src/djpegb.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Djpegb = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function replaceExtension(inputPath, outputExtension) {
     const parsed = path_1.default.parse(inputPath);
     const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
@@ -35,5 +36,30 @@ class Djpegb {
             stderr: result.stderr
         };
     }
+    async decompressStream(outputExtension, input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [outputExtension, inputPath];
+            if (options.rawOut) {
+                args.push('-raw_out');
+            }
+            if (options.nonInterleaved) {
+                args.push('-nonintrlv');
+            }
+            const result = (0, nbis_runtime_1.runNbis)('djpegb', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'djpegb');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const parsed = path_1.default.parse(inputPath);
+            const nistcomPath = path_1.default.join(parsed.dir, `${parsed.name}.ncm`);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            const nistcomBuffer = await (0, temp_io_1.readFileIfExists)(nistcomPath);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer,
+                nistcomBuffer
+            };
+        });
+    }
 }
 exports.Djpegb = Djpegb;

package/dist/src/djpegl.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type DjpeglOptions = {
     rawOut?: boolean;
     nonInterleaved?: boolean;
@@ -8,7 +9,15 @@ export type DjpeglResult = {
     stdout: string;
     stderr: string;
 };
+export type DjpeglStreamOptions = DjpeglOptions & StreamIoOptions;
+export type DjpeglStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+    nistcomBuffer?: Buffer;
+};
 export declare class Djpegl {
     version(): string;
     decompress(outputExtension: string, imagePath: string, options?: DjpeglOptions): DjpeglResult;
+    decompressStream(outputExtension: string, input: StreamInput, options?: DjpeglStreamOptions): Promise<DjpeglStreamResult>;
 }

package/dist/src/djpegl.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Djpegl = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function replaceExtension(inputPath, outputExtension) {
     const parsed = path_1.default.parse(inputPath);
     const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
@@ -35,5 +36,30 @@ class Djpegl {
             stderr: result.stderr
         };
     }
+    async decompressStream(outputExtension, input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [outputExtension, inputPath];
+            if (options.rawOut) {
+                args.push('-raw_out');
+            }
+            if (options.nonInterleaved) {
+                args.push('-nonintrlv');
+            }
+            const result = (0, nbis_runtime_1.runNbis)('djpegl', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'djpegl');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const parsed = path_1.default.parse(inputPath);
+            const nistcomPath = path_1.default.join(parsed.dir, `${parsed.name}.ncm`);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            const nistcomBuffer = await (0, temp_io_1.readFileIfExists)(nistcomPath);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer,
+                nistcomBuffer
+            };
+        });
+    }
 }
 exports.Djpegl = Djpegl;

package/dist/src/dwsq.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type DwsqOptions = {
     rawOut?: boolean;
 };
@@ -7,7 +8,15 @@ export type DwsqResult = {
     stdout: string;
     stderr: string;
 };
+export type DwsqStreamOptions = DwsqOptions & StreamIoOptions;
+export type DwsqStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+    nistcomBuffer?: Buffer;
+};
 export declare class Dwsq {
     version(): string;
     decompress(outputExtension: string, imagePath: string, options?: DwsqOptions): DwsqResult;
+    decompressStream(outputExtension: string, input: StreamInput, options?: DwsqStreamOptions): Promise<DwsqStreamResult>;
 }

package/dist/src/dwsq.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dwsq = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function replaceExtension(inputPath, outputExtension) {
     const parsed = path_1.default.parse(inputPath);
     const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
@@ -32,5 +33,27 @@ class Dwsq {
             stderr: result.stderr
         };
     }
+    async decompressStream(outputExtension, input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [outputExtension, inputPath];
+            if (options.rawOut) {
+                args.push('-raw_out');
+            }
+            const result = (0, nbis_runtime_1.runNbis)('dwsq', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'dwsq');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const parsed = path_1.default.parse(inputPath);
+            const nistcomPath = path_1.default.join(parsed.dir, `${parsed.name}.ncm`);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            const nistcomBuffer = await (0, temp_io_1.readFileIfExists)(nistcomPath);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer,
+                nistcomBuffer
+            };
+        });
+    }
 }
 exports.Dwsq = Dwsq;

package/dist/src/image-convert.d.ts

@@ -0,0 +1,17 @@
+export type AutoConvertConfig = {
+    enabled?: boolean;
+    wsqBitrate?: number;
+    ppi?: number;
+};
+export type NormalizedAutoConvertConfig = {
+    enabled: boolean;
+    wsqBitrate: number;
+    ppi?: number;
+};
+export type PreparedImage = {
+    path: string;
+    cleanup?: () => void;
+    converted?: boolean;
+};
+export declare function prepareFingerprintImageSync(inputPath: string, options?: boolean | AutoConvertConfig, tempDir?: string): PreparedImage;
+export declare function normalizeAutoConvertConfig(options?: boolean | AutoConvertConfig): NormalizedAutoConvertConfig;

package/dist/src/image-convert.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareFingerprintImageSync = prepareFingerprintImageSync;
+exports.normalizeAutoConvertConfig = normalizeAutoConvertConfig;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const pngjs_1 = require("pngjs");
+const jpeg_js_1 = __importDefault(require("jpeg-js"));
+const nbis_runtime_1 = require("./nbis-runtime");
+const SUPPORTED_ANSI_NIST_EXTENSIONS = new Set(['.an2', '.an2k', '.an2k7', '.eft']);
+function normalizeAutoConvert(config) {
+    if (config == null) {
+        return { enabled: true, wsqBitrate: 0.75 };
+    }
+    if (typeof config === 'boolean') {
+        return { enabled: config, wsqBitrate: 0.75 };
+    }
+    return {
+        enabled: config.enabled ?? true,
+        wsqBitrate: config.wsqBitrate ?? 0.75,
+        ppi: config.ppi
+    };
+}
+function detectFormat(inputPath) {
+    const ext = path_1.default.extname(inputPath).toLowerCase();
+    if (ext === '.wsq') {
+        return 'wsq';
+    }
+    if (SUPPORTED_ANSI_NIST_EXTENSIONS.has(ext)) {
+        return 'ansi-nist';
+    }
+    const fd = fs_1.default.openSync(inputPath, 'r');
+    try {
+        const header = Buffer.alloc(8);
+        const bytes = fs_1.default.readSync(fd, header, 0, header.length, 0);
+        if (bytes >= 8 && header.slice(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+            return 'png';
+        }
+        if (bytes >= 3 && header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff) {
+            return 'jpeg';
+        }
+    }
+    finally {
+        fs_1.default.closeSync(fd);
+    }
+    return 'unknown';
+}
+function toGrayscale(rgba) {
+    const pixelCount = Math.floor(rgba.length / 4);
+    const gray = Buffer.alloc(pixelCount);
+    for (let i = 0; i < pixelCount; i += 1) {
+        const idx = i * 4;
+        const r = rgba[idx];
+        const g = rgba[idx + 1];
+        const b = rgba[idx + 2];
+        gray[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+    }
+    return gray;
+}
+function decodeImage(inputPath, format) {
+    const data = fs_1.default.readFileSync(inputPath);
+    if (format === 'png') {
+        const decoded = pngjs_1.PNG.sync.read(data);
+        return { width: decoded.width, height: decoded.height, pixels: toGrayscale(decoded.data) };
+    }
+    const decoded = jpeg_js_1.default.decode(data, { useTArray: true });
+    if (!decoded || !decoded.data) {
+        throw new Error('jpeg decode failed.');
+    }
+    return { width: decoded.width, height: decoded.height, pixels: toGrayscale(Buffer.from(decoded.data)) };
+}
+function replaceExtension(inputPath, outputExtension) {
+    const parsed = path_1.default.parse(inputPath);
+    const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
+    return path_1.default.join(parsed.dir, `${parsed.name}${ext}`);
+}
+function convertToWsq(inputPath, tempDir, config) {
+    const format = detectFormat(inputPath);
+    if (format !== 'png' && format !== 'jpeg') {
+        return inputPath;
+    }
+    const decoded = decodeImage(inputPath, format);
+    const rawPath = path_1.default.join(tempDir, 'input.raw');
+    fs_1.default.writeFileSync(rawPath, decoded.pixels);
+    const rawAttrs = [decoded.width, decoded.height, 8];
+    if (config.ppi != null) {
+        rawAttrs.push(config.ppi);
+    }
+    const args = [String(config.wsqBitrate), 'wsq', rawPath, '-raw_in', rawAttrs.join(',')];
+    const result = (0, nbis_runtime_1.runNbis)('cwsq', args);
+    (0, nbis_runtime_1.assertSuccess)(result, 'cwsq (auto-convert)');
+    return replaceExtension(rawPath, 'wsq');
+}
+function prepareFingerprintImageSync(inputPath, options, tempDir) {
+    const config = normalizeAutoConvert(options);
+    if (!config.enabled) {
+        return { path: inputPath };
+    }
+    const format = detectFormat(inputPath);
+    if (format === 'wsq' || format === 'ansi-nist' || format === 'unknown') {
+        return { path: inputPath };
+    }
+    const ownedTempDir = tempDir ?? fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'nbis-img-'));
+    const convertedPath = convertToWsq(inputPath, ownedTempDir, config);
+    const cleanup = tempDir
+        ? undefined
+        : () => {
+            fs_1.default.rmSync(ownedTempDir, { recursive: true, force: true });
+        };
+    return { path: convertedPath, cleanup, converted: convertedPath !== inputPath };
+}
+function normalizeAutoConvertConfig(options) {
+    return normalizeAutoConvert(options);
+}

package/dist/src/intr2not.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type Intr2notOptions = {
     rawIn?: {
         width: number;
@@ -16,7 +17,14 @@ export type Intr2notResult = {
     stdout: string;
     stderr: string;
 };
+export type Intr2notStreamOptions = Intr2notOptions & StreamIoOptions;
+export type Intr2notStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Intr2not {
     version(): string;
     convert(outputExtension: string, imagePath: string, options?: Intr2notOptions): Intr2notResult;
+    convertStream(outputExtension: string, input: StreamInput, options?: Intr2notStreamOptions): Promise<Intr2notStreamResult>;
 }