nbis-wrapper-js 0.0.1 → 0.2.0

package/dist/src/temp-io.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTempDir = withTempDir;
+exports.writeTempInput = writeTempInput;
+exports.deliverTempOutput = deliverTempOutput;
+exports.readFileIfExists = readFileIfExists;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const stream_1 = require("stream");
+const promises_1 = require("stream/promises");
+function isReadableStream(value) {
+    return typeof value.pipe === 'function';
+}
+function normalizeExtension(extension) {
+    if (!extension) {
+        return '';
+    }
+    return extension.startsWith('.') ? extension : `.${extension}`;
+}
+function resolveInputName(input, nameOrOptions) {
+    if (!nameOrOptions) {
+        if (isReadableStream(input)) {
+            const streamPath = input.path;
+            if (typeof streamPath === 'string') {
+                return path_1.default.basename(streamPath);
+            }
+        }
+        return 'input';
+    }
+    if (typeof nameOrOptions === 'string') {
+        return nameOrOptions;
+    }
+    const extension = normalizeExtension(nameOrOptions.inputExtension);
+    if (nameOrOptions.inputName) {
+        if (extension && nameOrOptions.inputName.endsWith(extension)) {
+            return nameOrOptions.inputName;
+        }
+        return `${nameOrOptions.inputName}${extension}`;
+    }
+    if (extension) {
+        return `input${extension}`;
+    }
+    if (isReadableStream(input)) {
+        const streamPath = input.path;
+        if (typeof streamPath === 'string') {
+            return path_1.default.basename(streamPath);
+        }
+    }
+    return 'input';
+}
+async function withTempDir(fn) {
+    const tempDir = await fs_1.default.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'nbis-'));
+    try {
+        return await fn(tempDir);
+    }
+    finally {
+        await fs_1.default.promises.rm(tempDir, { recursive: true, force: true });
+    }
+}
+async function writeTempInput(tempDir, input, nameOrOptions) {
+    const resolvedName = resolveInputName(input, nameOrOptions);
+    const safeName = path_1.default.basename(resolvedName) || 'input';
+    const inputPath = path_1.default.join(tempDir, safeName);
+    if (isReadableStream(input)) {
+        await (0, promises_1.pipeline)(input, fs_1.default.createWriteStream(inputPath));
+        return inputPath;
+    }
+    const buffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+    await fs_1.default.promises.writeFile(inputPath, buffer);
+    return inputPath;
+}
+async function deliverTempOutput(outputPath, options = {}) {
+    if (options.output) {
+        if (options.outputToBuffer) {
+            const buffer = await fs_1.default.promises.readFile(outputPath);
+            await (0, promises_1.pipeline)(stream_1.Readable.from(buffer), options.output);
+            return buffer;
+        }
+        await (0, promises_1.pipeline)(fs_1.default.createReadStream(outputPath), options.output);
+        return undefined;
+    }
+    if (options.outputToBuffer === false) {
+        return undefined;
+    }
+    return fs_1.default.promises.readFile(outputPath);
+}
+async function readFileIfExists(filePath) {
+    try {
+        return await fs_1.default.promises.readFile(filePath);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw err;
+    }
+}

package/dist/src/wrjpgcom.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type WrjpgcomOptions = {
     replace?: boolean;
     commentFile: string;
@@ -14,7 +15,13 @@ export type WrjpgcomResult = {
     outputPath?: string;
     stderr: string;
 };
+export type WrjpgcomStreamOptions = Omit<WrjpgcomOptions, 'outputPath'> & StreamIoOptions;
+export type WrjpgcomStreamResult = {
+    outputBuffer?: Buffer;
+    stderr: string;
+};
 export declare class Wrjpgcom {
     version(): string;
     write(imagePath: string, options: WrjpgcomOptions): WrjpgcomResult;
+    writeStream(input: StreamInput, options: WrjpgcomStreamOptions): Promise<WrjpgcomStreamResult>;
 }

package/dist/src/wrjpgcom.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Wrjpgcom = void 0;
 const fs_1 = __importDefault(require("fs"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Wrjpgcom {
     version() {
         const result = (0, nbis_runtime_1.runNbisBinary)('wrjpgcom', ['-version']);
@@ -37,5 +38,30 @@ class Wrjpgcom {
             stderr: result.stderr.toString('utf8')
         };
     }
+    async writeStream(input, options) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const imagePath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [];
+            if (options.replace) {
+                args.push('-replace');
+            }
+            if (options.commentFile) {
+                args.push('-cfile', options.commentFile);
+            }
+            if (options.commentText) {
+                args.push('-comment', options.commentText);
+            }
+            args.push(imagePath);
+            const result = (0, nbis_runtime_1.runNbisBinary)('wrjpgcom', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'wrjpgcom');
+            const outputPath = `${imagePath}.out`;
+            await fs_1.default.promises.writeFile(outputPath, result.stdout);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                outputBuffer,
+                stderr: result.stderr.toString('utf8')
+            };
+        });
+    }
 }
 exports.Wrjpgcom = Wrjpgcom;

package/dist/src/wrwsqcom.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type WrwsqcomOptions = {
     commentFile: string;
     commentText?: never;
@@ -9,7 +10,14 @@ export type WrwsqcomResult = {
     stdout: string;
     stderr: string;
 };
+export type WrwsqcomStreamOptions = WrwsqcomOptions & StreamIoOptions;
+export type WrwsqcomStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Wrwsqcom {
     version(): string;
     write(imagePath: string, options: WrwsqcomOptions): WrwsqcomResult;
+    writeStream(input: StreamInput, options: WrwsqcomStreamOptions): Promise<WrwsqcomStreamResult>;
 }

package/dist/src/wrwsqcom.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Wrwsqcom = void 0;
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Wrwsqcom {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('wrwsqcom', ['-version']);
@@ -23,5 +24,25 @@ class Wrwsqcom {
             stderr: result.stderr
         };
     }
+    async writeStream(input, options) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const imagePath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [imagePath];
+            if (options.commentFile) {
+                args.push('-f', options.commentFile);
+            }
+            if (options.commentText) {
+                args.push('-t', options.commentText);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('wrwsqcom', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'wrwsqcom');
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(imagePath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Wrwsqcom = Wrwsqcom;

package/dist/src/ycc2rgb.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type Ycc2rgbOptions = {
     rawOut?: boolean;
     nonInterleaved?: boolean;
@@ -12,6 +13,12 @@ export type Ycc2rgbResult = {
     stdout: string;
     stderr: string;
 };
+export type Ycc2rgbStreamOptions = Ycc2rgbOptions & StreamIoOptions;
+export type Ycc2rgbStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Ycc2rgb {
     version(): string;
     convert(outputExtension: string, imagePath: string, rawIn: {
@@ -20,4 +27,10 @@ export declare class Ycc2rgb {
         depth: number;
         ppi?: number;
     }, options?: Ycc2rgbOptions): Ycc2rgbResult;
+    convertStream(outputExtension: string, input: StreamInput, rawIn: {
+        width: number;
+        height: number;
+        depth: number;
+        ppi?: number;
+    }, options?: Ycc2rgbStreamOptions): Promise<Ycc2rgbStreamResult>;
 }

package/dist/src/ycc2rgb.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ycc2rgb = 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) {
@@ -47,5 +48,29 @@ class Ycc2rgb {
             stderr: result.stderr
         };
     }
+    async convertStream(outputExtension, input, rawIn, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [outputExtension, inputPath, buildRawAttr(rawIn)];
+            if (options.rawOut) {
+                args.push('-raw_out');
+            }
+            if (options.nonInterleaved) {
+                args.push('-nonintrlv');
+            }
+            if (options.yCbCr) {
+                args.push('-YCbCr', buildYCbCr(options.yCbCr));
+            }
+            const result = (0, nbis_runtime_1.runNbis)('ycc2rgb', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'ycc2rgb');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Ycc2rgb = Ycc2rgb;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nbis-wrapper-js",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Node.js wrappers for NBIS 5.0.0 binaries",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -44,6 +44,10 @@
     "test:nbis-versions": "npm run build && node dist/scripts/test-nbis-versions.js",
     "test": "npm run build && node dist/test/nbis-versions.test.js"
   },
+  "dependencies": {
+    "jpeg-js": "^0.4.4",
+    "pngjs": "^7.0.0"
+  },
   "devDependencies": {
     "@types/node": "^20.14.10",
     "typescript": "^5.4.5"