@blazediff/bin 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Teimur Gasanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_core = __toESM(require("@blazediff/core"));
+async function compareImages(image1Path, image2Path, options) {
+  const [image1, image2] = await Promise.all([
+    options.transformer.transform(image1Path),
+    options.transformer.transform(image2Path)
+  ]);
+  if (image1.width !== image2.width || image1.height !== image2.height) {
+    throw new Error(
+      `Image dimensions do not match: ${image1.width}x${image1.height} vs ${image2.width}x${image2.height}`
+    );
+  }
+  let outputData;
+  if (options.outputPath) {
+    outputData = new Uint8Array(image1.data.length);
+  }
+  const startTime = performance.now();
+  const diffCount = (0, import_core.default)(
+    image1.data,
+    image2.data,
+    outputData,
+    image1.width,
+    image1.height,
+    options.coreOptions
+  );
+  const duration = performance.now() - startTime;
+  return {
+    diffCount,
+    width: image1.width,
+    height: image1.height,
+    outputData,
+    duration
+  };
+}
+
+// src/cli.ts
+function printUsage() {
+  console.log(`
+Usage: blazediff <image1> <image2> [options]
+
+Arguments:
+  image1    Path to the first image
+  image2    Path to the second image
+
+Options:
+  -o, --output <path>       Output path for the diff image
+  -t, --threshold <num>     Matching threshold (0 to 1, default: 0.1)
+  -a, --alpha <num>         Opacity of original image in diff (default: 0.1)
+  --aa-color <r,g,b>        Color for anti-aliased pixels (default: 255,255,0)
+  --diff-color <r,g,b>      Color for different pixels (default: 255,0,0)
+  --diff-color-alt <r,g,b>  Alternative color for dark differences (default: same as diff-color)
+  --include-aa              Include anti-aliasing detection
+  --diff-mask               Draw diff over transparent background
+  --transformer <name>      Specify transformer to use (e.g. pngjs, sharp)
+  -h, --help                Show this help message
+
+Examples:
+  blazediff image1.png image2.png
+  blazediff image1.png image2.png -o diff.png -t 0.05
+  blazediff image1.png image2.png --threshold 0.2 --alpha 0.3
+`);
+}
+function parseRGB(colorStr) {
+  const parts = colorStr.split(",").map((s) => parseInt(s.trim()));
+  if (parts.length !== 3 || parts.some((p) => isNaN(p) || p < 0 || p > 255)) {
+    throw new Error(
+      `Invalid RGB color format: ${colorStr}. Expected format: r,g,b (e.g., 255,0,0)`
+    );
+  }
+  return [parts[0], parts[1], parts[2]];
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
+    printUsage();
+    process.exit(0);
+  }
+  if (args.length < 2) {
+    console.error("Error: Two image paths are required");
+    printUsage();
+    process.exit(1);
+  }
+  const image1 = args[0];
+  const image2 = args[1];
+  const options = {};
+  for (let i = 2; i < args.length; i++) {
+    const arg = args[i];
+    const nextArg = args[i + 1];
+    switch (arg) {
+      case "-o":
+      case "--output":
+        if (nextArg) {
+          options.outputPath = nextArg;
+          i++;
+        }
+        break;
+      case "-t":
+      case "--threshold":
+        if (nextArg) {
+          const threshold = parseFloat(nextArg);
+          if (isNaN(threshold) || threshold < 0 || threshold > 1) {
+            throw new Error(
+              `Invalid threshold: ${nextArg}. Must be between 0 and 1`
+            );
+          }
+          options.threshold = threshold;
+          i++;
+        }
+        break;
+      case "-a":
+      case "--alpha":
+        if (nextArg) {
+          const alpha = parseFloat(nextArg);
+          if (isNaN(alpha) || alpha < 0 || alpha > 1) {
+            throw new Error(
+              `Invalid alpha: ${nextArg}. Must be between 0 and 1`
+            );
+          }
+          options.alpha = alpha;
+          i++;
+        }
+        break;
+      case "--aa-color":
+        if (nextArg) {
+          options.aaColor = parseRGB(nextArg);
+          i++;
+        }
+        break;
+      case "--diff-color":
+        if (nextArg) {
+          options.diffColor = parseRGB(nextArg);
+          i++;
+        }
+        break;
+      case "--diff-color-alt":
+        if (nextArg) {
+          options.diffColorAlt = parseRGB(nextArg);
+          i++;
+        }
+        break;
+      case "--include-aa":
+        options.includeAA = true;
+        break;
+      case "--diff-mask":
+        options.diffMask = true;
+        break;
+      case "--transformer":
+        if (nextArg) {
+          options.transformer = nextArg;
+          i++;
+        }
+        break;
+      default:
+        console.error(`Unknown option: ${arg}`);
+        printUsage();
+        process.exit(1);
+    }
+  }
+  return { image1, image2, options };
+}
+var getTransformer = async (transformer) => {
+  if (!transformer || transformer === "pngjs") {
+    const { default: transformer2 } = await import("@blazediff/pngjs-transformer");
+    return transformer2;
+  }
+  if (transformer === "sharp") {
+    const { default: transformer2 } = await import("@blazediff/sharp-transformer");
+    return transformer2;
+  }
+  throw new Error(`Unknown transformer: ${transformer}`);
+};
+async function main() {
+  try {
+    const { image1, image2, options } = parseArgs();
+    const transformer = await getTransformer(options.transformer);
+    const result = await compareImages(image1, image2, {
+      outputPath: options.outputPath,
+      transformer,
+      coreOptions: {
+        threshold: options.threshold,
+        alpha: options.alpha,
+        aaColor: options.aaColor,
+        diffColor: options.diffColor,
+        diffColorAlt: options.diffColorAlt,
+        includeAA: options.includeAA,
+        diffMask: options.diffMask
+      }
+    });
+    console.log(`matched in: ${result.duration.toFixed(2)}ms`);
+    console.log(`dimensions: ${result.width}x${result.height}`);
+    console.log(`different pixels: ${result.diffCount}`);
+    console.log(
+      `error: ${(result.diffCount / (result.width * result.height) * 100).toFixed(2)}%`
+    );
+    if (options.outputPath && result.outputData) {
+      await transformer.write(
+        {
+          data: result.outputData,
+          width: result.width,
+          height: result.height
+        },
+        options.outputPath
+      );
+      console.log(`diff image: ${options.outputPath}`);
+    }
+    if (result.diffCount > 0) {
+      process.exit(1);
+    } else {
+      console.log(`Images are identical!`);
+      process.exit(0);
+    }
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+}
+if (typeof require !== "undefined" && require.main === module) {
+  main();
+}

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+import { BlazeDiffTransformer, BlazeDiffOptions } from '@blazediff/types';
+
+interface CompareImagesOptions {
+    outputPath?: string;
+    transformer: BlazeDiffTransformer;
+    coreOptions?: BlazeDiffOptions;
+}
+interface CompareImagesResult {
+    diffCount: number;
+    width: number;
+    height: number;
+    outputData?: Uint8Array;
+    duration: number;
+}
+declare function compareImages(image1Path: string, image2Path: string, options: CompareImagesOptions): Promise<CompareImagesResult>;
+
+export { type CompareImagesOptions, type CompareImagesResult, compareImages };

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { BlazeDiffTransformer, BlazeDiffOptions } from '@blazediff/types';
+
+interface CompareImagesOptions {
+    outputPath?: string;
+    transformer: BlazeDiffTransformer;
+    coreOptions?: BlazeDiffOptions;
+}
+interface CompareImagesResult {
+    diffCount: number;
+    width: number;
+    height: number;
+    outputData?: Uint8Array;
+    duration: number;
+}
+declare function compareImages(image1Path: string, image2Path: string, options: CompareImagesOptions): Promise<CompareImagesResult>;
+
+export { type CompareImagesOptions, type CompareImagesResult, compareImages };

package/dist/index.js

@@ -0,0 +1 @@
+'use strict';var s=require('@blazediff/core');function _interopDefault(e){return e&&e.__esModule?e:{default:e}}var s__default=/*#__PURE__*/_interopDefault(s);async function d(i,n,r){let[t,e]=await Promise.all([r.transformer.transform(i),r.transformer.transform(n)]);if(t.width!==e.width||t.height!==e.height)throw new Error(`Image dimensions do not match: ${t.width}x${t.height} vs ${e.width}x${e.height}`);let a;r.outputPath&&(a=new Uint8Array(t.data.length));let o=performance.now(),m=s__default.default(t.data,e.data,a,t.width,t.height,r.coreOptions),f=performance.now()-o;return {diffCount:m,width:t.width,height:t.height,outputData:a,duration:f}}exports.compareImages=d;

package/dist/index.mjs

@@ -0,0 +1 @@
+import s from'@blazediff/core';async function d(i,n,r){let[t,e]=await Promise.all([r.transformer.transform(i),r.transformer.transform(n)]);if(t.width!==e.width||t.height!==e.height)throw new Error(`Image dimensions do not match: ${t.width}x${t.height} vs ${e.width}x${e.height}`);let a;r.outputPath&&(a=new Uint8Array(t.data.length));let o=performance.now(),m=s(t.data,e.data,a,t.width,t.height,r.coreOptions),f=performance.now()-o;return {diffCount:m,width:t.width,height:t.height,outputData:a,duration:f}}export{d as compareImages};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@blazediff/bin",
+  "version": "0.0.1",
+  "description": "Command-line interface for the blazediff image comparison library",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "blazediff": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./cli": {
+      "import": "./dist/cli.mjs",
+      "require": "./dist/cli.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "cli",
+    "image",
+    "comparison",
+    "diff"
+  ],
+  "author": "Teimur Gasanov <me@teimurjan.dev> (https://github.com/teimurjan)",
+  "repository": "https://github.com/teimurjan/blazediff",
+  "homepage": "https://github.com/teimurjan/blazediff",
+  "license": "MIT",
+  "dependencies": {
+    "@blazediff/core": "0.0.1",
+    "@blazediff/pngjs-transformer": "0.0.1",
+    "@blazediff/sharp-transformer": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "tsup": "8.5.0",
+    "typescript": "5.9.2",
+    "@blazediff/types": "0.0.1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  }
+}