nbis-wrapper-js 0.0.1 → 0.2.0

package/README.md

@@ -37,6 +37,56 @@ const score = nfiq.score('sample.wsq');
 console.log(score.scores);
 ```
 
+## Stream IO (optional)
+
+For file-based commands, async `*Stream` methods accept a stream or buffer and use
+temporary files under the hood. Outputs can be returned as a buffer or piped to a
+stream.
+
+Most wrappers that take file paths now have `*Stream` counterparts. Commands with
+multiple outputs (e.g., `mindtct`) return an `outputBuffers` map unless you provide
+per-output streams. `mindtct.detectStream` only returns buffers when `outputToBuffer`
+is set.
+
+Stream inputs also accept `inputName`/`inputExtension` (for tools that infer format
+from filenames). For `Bozorth3`, you can pass `{ input, label }` to keep stable
+`probe`/`gallery` identifiers in results.
+
+## Image Auto-Convert (default on)
+
+`Mindtct` and `Nfiq` can auto-convert PNG/JPEG inputs into WSQ before invoking NBIS.
+This is enabled by default and can be disabled via the constructor.
+
+```ts
+import { Mindtct } from 'nbis-wrapper-js';
+
+const mindtct = new Mindtct({ autoConvert: false });
+
+// Or tune WSQ conversion:
+const tuned = new Mindtct({
+  autoConvert: { wsqBitrate: 0.75, ppi: 500 }
+});
+```
+
+```ts
+import fs from 'fs';
+import { Cwsq } from 'nbis-wrapper-js';
+
+const cwsq = new Cwsq();
+const inputStream = fs.createReadStream('sample.raw');
+
+const result = await cwsq.compressStream(0.75, 'wsq', inputStream, {
+  rawIn: { width: 500, height: 500, depth: 8 },
+  output: fs.createWriteStream('out.wsq')
+});
+
+// Or return a buffer instead of piping:
+const { outputBuffer } = await cwsq.compressStream(0.75, 'wsq', inputStream, {
+  rawIn: { width: 500, height: 500, depth: 8 },
+  outputToBuffer: true
+});
+```
+
 ## API Overview
 
 ### Fingerprint

package/dist/src/an2ktool.d.ts

@@ -1,7 +1,12 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type An2kToolResult = {
     stdout: string;
     stderr: string;
 };
+export type An2kToolStreamResult = An2kToolResult & {
+    outputBuffer?: Buffer;
+};
+export type An2kToolStreamOptions = StreamIoOptions;
 export declare class An2kTool {
     version(): string;
     printAll(fileIn: string, fileOut?: string): An2kToolResult;
@@ -11,4 +16,11 @@ export declare class An2kTool {
     substituteFormatted(selection: string, fmtFile: string, fileIn: string, fileOut?: string): An2kToolResult;
     insertValue(selection: string, newValue: string, fileIn: string, fileOut?: string): An2kToolResult;
     insertFormatted(selection: string, fmtFile: string, fileIn: string, fileOut?: string): An2kToolResult;
+    printAllStream(input: StreamInput, options?: An2kToolStreamOptions): Promise<An2kToolStreamResult>;
+    printSelectionStream(selection: string, input: StreamInput, options?: An2kToolStreamOptions): Promise<An2kToolStreamResult>;
+    deleteSelectionStream(selection: string, input: StreamInput, options?: An2kToolStreamOptions): Promise<An2kToolStreamResult>;
+    substituteValueStream(selection: string, newValue: string, input: StreamInput, options?: An2kToolStreamOptions): Promise<An2kToolStreamResult>;
+    substituteFormattedStream(selection: string, fmtFile: string, input: StreamInput, options?: An2kToolStreamOptions): Promise<An2kToolStreamResult>;
+    insertValueStream(selection: string, newValue: string, input: StreamInput, options?: An2kToolStreamOptions): Promise<An2kToolStreamResult>;
+    insertFormattedStream(selection: string, fmtFile: string, input: StreamInput, options?: An2kToolStreamOptions): Promise<An2kToolStreamResult>;
 }

package/dist/src/an2ktool.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.An2kTool = void 0;
+const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function runAn2kTool(args, context) {
     const result = (0, nbis_runtime_1.runNbis)('an2ktool', args);
     (0, nbis_runtime_1.assertSuccess)(result, context);
@@ -17,6 +22,20 @@ function buildFileArgs(fileIn, fileOut) {
     }
     return args;
 }
+async function runAn2kToolStream(argsBuilder, context, input, options = {}) {
+    return (0, temp_io_1.withTempDir)(async (tempDir) => {
+        const fileIn = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+        const fileOut = path_1.default.join(tempDir, 'output.an2k');
+        const result = (0, nbis_runtime_1.runNbis)('an2ktool', argsBuilder(fileIn, fileOut));
+        (0, nbis_runtime_1.assertSuccess)(result, context);
+        const outputBuffer = await (0, temp_io_1.deliverTempOutput)(fileOut, options);
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            outputBuffer
+        };
+    });
+}
 class An2kTool {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('an2ktool', ['-version']);
@@ -44,5 +63,26 @@ class An2kTool {
     insertFormatted(selection, fmtFile, fileIn, fileOut) {
         return runAn2kTool(['-insert', selection, fmtFile, ...buildFileArgs(fileIn, fileOut)], 'an2ktool insert');
     }
+    printAllStream(input, options = {}) {
+        return runAn2kToolStream((fileIn, fileOut) => ['-print', 'all', ...buildFileArgs(fileIn, fileOut)], 'an2ktool print', input, options);
+    }
+    printSelectionStream(selection, input, options = {}) {
+        return runAn2kToolStream((fileIn, fileOut) => ['-print', selection, ...buildFileArgs(fileIn, fileOut)], 'an2ktool print', input, options);
+    }
+    deleteSelectionStream(selection, input, options = {}) {
+        return runAn2kToolStream((fileIn, fileOut) => ['-delete', selection, ...buildFileArgs(fileIn, fileOut)], 'an2ktool delete', input, options);
+    }
+    substituteValueStream(selection, newValue, input, options = {}) {
+        return runAn2kToolStream((fileIn, fileOut) => ['-substitute', selection, newValue, ...buildFileArgs(fileIn, fileOut)], 'an2ktool substitute', input, options);
+    }
+    substituteFormattedStream(selection, fmtFile, input, options = {}) {
+        return runAn2kToolStream((fileIn, fileOut) => ['-substitute', selection, fmtFile, ...buildFileArgs(fileIn, fileOut)], 'an2ktool substitute', input, options);
+    }
+    insertValueStream(selection, newValue, input, options = {}) {
+        return runAn2kToolStream((fileIn, fileOut) => ['-insert', selection, newValue, ...buildFileArgs(fileIn, fileOut)], 'an2ktool insert', input, options);
+    }
+    insertFormattedStream(selection, fmtFile, input, options = {}) {
+        return runAn2kToolStream((fileIn, fileOut) => ['-insert', selection, fmtFile, ...buildFileArgs(fileIn, fileOut)], 'an2ktool insert', input, options);
+    }
 }
 exports.An2kTool = An2kTool;

package/dist/src/bozorth3.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput } from './temp-io';
 export type BozorthOptions = {
     m1?: boolean;
     maxMinutiae?: number;
@@ -28,6 +29,10 @@ export type BozorthResult = {
     stdout: string;
     stderr: string;
 };
+export type BozorthStreamInput = StreamInput | {
+    input: StreamInput;
+    label?: string;
+};
 export declare class Bozorth3 {
     version(): string;
     matchPair(probeFile: string, galleryFile: string, options?: BozorthOptions): BozorthResult;
@@ -38,6 +43,17 @@ export declare class Bozorth3 {
     matchWithFixedProbeList(probeFile: string, galleryListFile: string, options?: BozorthOptions): BozorthResult;
     matchWithFixedGallery(galleryFile: string, probeFiles?: string[], options?: BozorthOptions): BozorthResult;
     matchWithFixedGalleryList(galleryFile: string, probeListFile: string, options?: BozorthOptions): BozorthResult;
+    matchPairStream(probeInput: BozorthStreamInput, galleryInput: BozorthStreamInput, options?: BozorthOptions): Promise<BozorthResult>;
+    matchMatesListStream(mates: Array<{
+        probe: BozorthStreamInput;
+        gallery: BozorthStreamInput;
+    }>, options?: BozorthOptions): Promise<BozorthResult>;
+    matchProbeListStream(probeInputs: BozorthStreamInput[], galleryInputs?: BozorthStreamInput[], options?: BozorthOptions): Promise<BozorthResult>;
+    matchGalleryListStream(galleryInputs: BozorthStreamInput[], probeInputs?: BozorthStreamInput[], options?: BozorthOptions): Promise<BozorthResult>;
+    matchWithFixedProbeStream(probeInput: BozorthStreamInput, galleryInputs?: BozorthStreamInput[], options?: BozorthOptions): Promise<BozorthResult>;
+    matchWithFixedProbeListStream(probeInput: BozorthStreamInput, galleryInputs: BozorthStreamInput[], options?: BozorthOptions): Promise<BozorthResult>;
+    matchWithFixedGalleryStream(galleryInput: BozorthStreamInput, probeInputs?: BozorthStreamInput[], options?: BozorthOptions): Promise<BozorthResult>;
+    matchWithFixedGalleryListStream(galleryInput: BozorthStreamInput, probeInputs: BozorthStreamInput[], options?: BozorthOptions): Promise<BozorthResult>;
     private withDefaultFormat;
     private runMatch;
 }

package/dist/src/bozorth3.js

@@ -1,7 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bozorth3 = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function buildBozorthArgs(options = {}) {
     const args = [];
     if (options.m1) {
@@ -92,6 +98,45 @@ function parseBozorthOutput(output, outFormat) {
         return entry;
     });
 }
+function normalizeStreamInput(entry) {
+    if (typeof entry === 'object' && entry != null && 'input' in entry) {
+        return entry;
+    }
+    return { input: entry };
+}
+function applyLabelMap(results, labelMap) {
+    if (!labelMap || labelMap.size === 0) {
+        return results;
+    }
+    return results.map((result) => {
+        const updated = { ...result };
+        if (updated.probe && labelMap.has(updated.probe)) {
+            updated.probe = labelMap.get(updated.probe);
+        }
+        if (updated.gallery && labelMap.has(updated.gallery)) {
+            updated.gallery = labelMap.get(updated.gallery);
+        }
+        return updated;
+    });
+}
+async function writeInputFiles(tempDir, inputs, prefix, labelMap) {
+    const paths = [];
+    for (let i = 0; i < inputs.length; i += 1) {
+        const { input, label } = normalizeStreamInput(inputs[i]);
+        const filePath = await (0, temp_io_1.writeTempInput)(tempDir, input, `${prefix}-${i}.xyt`);
+        if (label) {
+            labelMap.set(filePath, label);
+        }
+        paths.push(filePath);
+    }
+    return paths;
+}
+async function writeListFile(tempDir, name, lines) {
+    const listPath = path_1.default.join(tempDir, name);
+    const content = lines.length ? `${lines.join('\n')}\n` : '';
+    await fs_1.default.promises.writeFile(listPath, content);
+    return listPath;
+}
 class Bozorth3 {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('bozorth3', ['-version']);
@@ -122,6 +167,111 @@ class Bozorth3 {
     matchWithFixedGalleryList(galleryFile, probeListFile, options = {}) {
         return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-g', galleryFile, '-P', probeListFile], options);
     }
+    async matchPairStream(probeInput, galleryInput, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const labelMap = new Map();
+            const probeEntry = normalizeStreamInput(probeInput);
+            const galleryEntry = normalizeStreamInput(galleryInput);
+            const probeFile = await (0, temp_io_1.writeTempInput)(tempDir, probeEntry.input, 'probe.xyt');
+            const galleryFile = await (0, temp_io_1.writeTempInput)(tempDir, galleryEntry.input, 'gallery.xyt');
+            if (probeEntry.label) {
+                labelMap.set(probeFile, probeEntry.label);
+            }
+            if (galleryEntry.label) {
+                labelMap.set(galleryFile, galleryEntry.label);
+            }
+            return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), probeFile, galleryFile], options, labelMap);
+        });
+    }
+    async matchMatesListStream(mates, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const labelMap = new Map();
+            const lines = [];
+            for (let i = 0; i < mates.length; i += 1) {
+                const probeEntry = normalizeStreamInput(mates[i].probe);
+                const galleryEntry = normalizeStreamInput(mates[i].gallery);
+                const probeFile = await (0, temp_io_1.writeTempInput)(tempDir, probeEntry.input, `probe-${i}.xyt`);
+                const galleryFile = await (0, temp_io_1.writeTempInput)(tempDir, galleryEntry.input, `gallery-${i}.xyt`);
+                if (probeEntry.label) {
+                    labelMap.set(probeFile, probeEntry.label);
+                }
+                if (galleryEntry.label) {
+                    labelMap.set(galleryFile, galleryEntry.label);
+                }
+                lines.push(probeFile, galleryFile);
+            }
+            const matesListFile = await writeListFile(tempDir, 'mates.lis', lines);
+            return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-M', matesListFile], options, labelMap);
+        });
+    }
+    async matchProbeListStream(probeInputs, galleryInputs = [], options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const labelMap = new Map();
+            const probeFiles = await writeInputFiles(tempDir, probeInputs, 'probe', labelMap);
+            const galleryFiles = await writeInputFiles(tempDir, galleryInputs, 'gallery', labelMap);
+            const probeListFile = await writeListFile(tempDir, 'probe.lis', probeFiles);
+            return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-P', probeListFile, ...galleryFiles], options, labelMap);
+        });
+    }
+    async matchGalleryListStream(galleryInputs, probeInputs = [], options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const labelMap = new Map();
+            const galleryFiles = await writeInputFiles(tempDir, galleryInputs, 'gallery', labelMap);
+            const probeFiles = await writeInputFiles(tempDir, probeInputs, 'probe', labelMap);
+            const galleryListFile = await writeListFile(tempDir, 'gallery.lis', galleryFiles);
+            return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-G', galleryListFile, ...probeFiles], options, labelMap);
+        });
+    }
+    async matchWithFixedProbeStream(probeInput, galleryInputs = [], options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const labelMap = new Map();
+            const probeEntry = normalizeStreamInput(probeInput);
+            const probeFile = await (0, temp_io_1.writeTempInput)(tempDir, probeEntry.input, 'probe.xyt');
+            if (probeEntry.label) {
+                labelMap.set(probeFile, probeEntry.label);
+            }
+            const galleryFiles = await writeInputFiles(tempDir, galleryInputs, 'gallery', labelMap);
+            return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-p', probeFile, ...galleryFiles], options, labelMap);
+        });
+    }
+    async matchWithFixedProbeListStream(probeInput, galleryInputs, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const labelMap = new Map();
+            const probeEntry = normalizeStreamInput(probeInput);
+            const probeFile = await (0, temp_io_1.writeTempInput)(tempDir, probeEntry.input, 'probe.xyt');
+            if (probeEntry.label) {
+                labelMap.set(probeFile, probeEntry.label);
+            }
+            const galleryFiles = await writeInputFiles(tempDir, galleryInputs, 'gallery', labelMap);
+            const galleryListFile = await writeListFile(tempDir, 'gallery.lis', galleryFiles);
+            return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-p', probeFile, '-G', galleryListFile], options, labelMap);
+        });
+    }
+    async matchWithFixedGalleryStream(galleryInput, probeInputs = [], options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const labelMap = new Map();
+            const galleryEntry = normalizeStreamInput(galleryInput);
+            const galleryFile = await (0, temp_io_1.writeTempInput)(tempDir, galleryEntry.input, 'gallery.xyt');
+            if (galleryEntry.label) {
+                labelMap.set(galleryFile, galleryEntry.label);
+            }
+            const probeFiles = await writeInputFiles(tempDir, probeInputs, 'probe', labelMap);
+            return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-g', galleryFile, ...probeFiles], options, labelMap);
+        });
+    }
+    async matchWithFixedGalleryListStream(galleryInput, probeInputs, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const labelMap = new Map();
+            const galleryEntry = normalizeStreamInput(galleryInput);
+            const galleryFile = await (0, temp_io_1.writeTempInput)(tempDir, galleryEntry.input, 'gallery.xyt');
+            if (galleryEntry.label) {
+                labelMap.set(galleryFile, galleryEntry.label);
+            }
+            const probeFiles = await writeInputFiles(tempDir, probeInputs, 'probe', labelMap);
+            const probeListFile = await writeListFile(tempDir, 'probe.lis', probeFiles);
+            return this.runMatch([...buildBozorthArgs(this.withDefaultFormat(options)), '-g', galleryFile, '-P', probeListFile], options, labelMap);
+        });
+    }
     withDefaultFormat(options) {
         if (options.outFormat) {
             return options;
@@ -131,12 +281,12 @@ class Bozorth3 {
             outFormat: 'spg'
         };
     }
-    runMatch(args, options) {
+    runMatch(args, options, labelMap) {
         const result = (0, nbis_runtime_1.runNbis)('bozorth3', args);
         (0, nbis_runtime_1.assertSuccess)(result, 'bozorth3');
         const format = options.outFormat || 'spg';
         return {
-            results: parseBozorthOutput(result.stdout, format),
+            results: applyLabelMap(parseBozorthOutput(result.stdout, format), labelMap),
             stdout: result.stdout,
             stderr: result.stderr
         };

package/dist/src/chkan2k.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput } from './temp-io';
 export type Chkan2kOptions = {
     baseConfigFile?: string;
     extraConfigFiles?: string[];
@@ -11,4 +12,5 @@ export type Chkan2kResult = {
 export declare class Chkan2k {
     version(): string;
     check(files: string[], options?: Chkan2kOptions): Chkan2kResult;
+    checkStream(inputs: StreamInput[], options?: Chkan2kOptions): Promise<Chkan2kResult>;
 }

package/dist/src/chkan2k.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Chkan2k = void 0;
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Chkan2k {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('chkan2k', ['-version']);
@@ -30,5 +31,34 @@ class Chkan2k {
             stderr: result.stderr
         };
     }
+    async checkStream(inputs, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const files = [];
+            for (let i = 0; i < inputs.length; i += 1) {
+                const filePath = await (0, temp_io_1.writeTempInput)(tempDir, inputs[i], `input-${i}.an2k`);
+                files.push(filePath);
+            }
+            const args = [];
+            if (options.baseConfigFile) {
+                args.push('-b', options.baseConfigFile);
+            }
+            if (options.extraConfigFiles) {
+                options.extraConfigFiles.forEach((file) => args.push('-c', file));
+            }
+            if (options.logLevel) {
+                args.push('-l', options.logLevel);
+            }
+            if (options.help) {
+                args.push('-h');
+            }
+            args.push(...files);
+            const result = (0, nbis_runtime_1.runNbis)('chkan2k', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'chkan2k');
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
+        });
+    }
 }
 exports.Chkan2k = Chkan2k;

package/dist/src/cjp2k.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type Cjp2kOptions = {
     inputPath?: string;
     outputPath?: string;
@@ -15,7 +16,16 @@ export type Cjp2kResult = {
     stdout: string;
     stderr: string;
 };
+export type Cjp2kStreamOptions = Omit<Cjp2kOptions, 'inputPath' | 'outputPath' | 'imageDir'> & StreamIoOptions & {
+    outputExtension?: string;
+};
+export type Cjp2kStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Cjp2k {
     version(): string;
     compress(options: Cjp2kOptions): Cjp2kResult;
+    compressStream(input: StreamInput, options?: Cjp2kStreamOptions): Promise<Cjp2kStreamResult>;
 }

package/dist/src/cjp2k.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.Cjp2k = 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 Cjp2k {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('cjp2k', ['-version']);
@@ -50,5 +61,45 @@ class Cjp2k {
             stderr: result.stderr
         };
     }
+    async compressStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const extension = normalizeExtension(options.outputExtension || 'jp2');
+            const outputPath = path_1.default.join(tempDir, `output${extension}`);
+            const args = ['-i', inputPath, '-o', outputPath];
+            if (options.outputFormat) {
+                args.push('-OutFor', options.outputFormat);
+            }
+            if (options.rawFormat) {
+                args.push('-F', options.rawFormat);
+            }
+            if (options.nistLossy) {
+                args.push('-NIST-fingerprint-lossy');
+            }
+            if (options.nistLossless) {
+                args.push('-NIST-fingerprint-lossless');
+            }
+            if (options.compressionRatios && options.compressionRatios.length) {
+                args.push('-r', options.compressionRatios.join(','));
+            }
+            if (options.psnr && options.psnr.length) {
+                args.push('-q', options.psnr.join(','));
+            }
+            if (options.ppi != null) {
+                args.push('-PPI', String(options.ppi));
+            }
+            if (options.extraArgs) {
+                args.push(...options.extraArgs);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('cjp2k', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'cjp2k');
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Cjp2k = Cjp2k;

package/dist/src/cjpeg.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type CjpegOptions = {
     quality?: number;
     grayscale?: boolean;
@@ -19,6 +20,13 @@ export type CjpegResult = {
     stderr: string;
     outputPath?: string;
 };
+export type CjpegStreamOptions = Omit<CjpegOptions, 'outputPath'> & StreamIoOptions;
+export type CjpegStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Cjpeg {
     compress(inputPath: string, options?: CjpegOptions): CjpegResult;
+    compressStream(input: StreamInput, options?: CjpegStreamOptions): Promise<CjpegStreamResult>;
 }

package/dist/src/cjpeg.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.Cjpeg = void 0;
+const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Cjpeg {
     compress(inputPath, options = {}) {
         const args = [];
@@ -56,5 +61,61 @@ class Cjpeg {
             outputPath: options.outputPath
         };
     }
+    async compressStream(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.jpg');
+            const args = [];
+            if (options.quality != null) {
+                args.push('-quality', String(options.quality));
+            }
+            if (options.grayscale) {
+                args.push('-grayscale');
+            }
+            if (options.optimize) {
+                args.push('-optimize');
+            }
+            if (options.progressive) {
+                args.push('-progressive');
+            }
+            if (options.targa) {
+                args.push('-targa');
+            }
+            if (options.dct) {
+                args.push('-dct', options.dct);
+            }
+            if (options.restart != null) {
+                args.push('-restart', String(options.restart));
+            }
+            if (options.smooth != null) {
+                args.push('-smooth', String(options.smooth));
+            }
+            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.baseline) {
+                args.push('-baseline');
+            }
+            if (options.extraArgs) {
+                args.push(...options.extraArgs);
+            }
+            args.push(inputPath);
+            const result = (0, nbis_runtime_1.runNbis)('cjpeg', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'cjpeg');
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Cjpeg = Cjpeg;

package/dist/src/cjpegb.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type CjpegbOptions = {
     rawIn?: {
         width: number;
@@ -13,7 +14,14 @@ export type CjpegbResult = {
     stdout: string;
     stderr: string;
 };
+export type CjpegbStreamOptions = CjpegbOptions & StreamIoOptions;
+export type CjpegbStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Cjpegb {
     version(): string;
     compress(quality: number, outputExtension: string, imagePath: string, options?: CjpegbOptions): CjpegbResult;
+    compressStream(quality: number, outputExtension: string, input: StreamInput, options?: CjpegbStreamOptions): Promise<CjpegbStreamResult>;
 }

package/dist/src/cjpegb.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cjpegb = 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) {
@@ -43,5 +44,29 @@ class Cjpegb {
             stderr: result.stderr
         };
     }
+    async compressStream(quality, 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(quality), outputExtension, inputPath];
+            if (options.rawIn) {
+                args.push('-raw_in', buildRawAttr(options.rawIn));
+            }
+            if (options.nonInterleaved) {
+                args.push('-nonintrlv');
+            }
+            if (options.commentFile) {
+                args.push(options.commentFile);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('cjpegb', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'cjpegb');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Cjpegb = Cjpegb;