@superdoc-dev/visual-benchmarks 0.2.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 SuperDoc
+
+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/README.md

@@ -0,0 +1,47 @@
+# superdoc-benchmark (npm wrapper)
+
+This npm package installs a lightweight wrapper that downloads the macOS
+binary from GitHub Releases on install.
+
+## Requirements
+
+- macOS
+- Microsoft Word
+- Node.js (npm)
+
+## Install
+
+```bash
+npm install -g @superdoc-dev/visual-benchmarks
+```
+
+## Run
+
+```bash
+superdoc-benchmark
+superdoc-benchmark compare ./docs/
+```
+
+## Update
+
+```bash
+npm update -g @superdoc-dev/visual-benchmarks
+```
+
+## Publish (maintainers)
+
+From the `npm/` folder:
+
+```bash
+npm run publish
+```
+
+## Troubleshooting
+
+If the download fails, you can run from source instead:
+
+```bash
+git clone https://github.com/superdoc-dev/superdoc-visual-benchmarks
+cd superdoc-visual-benchmarks
+uv run superdoc-benchmark
+```

package/bin/cli.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawn, execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const http = require("http");
+const https = require("https");
+const readline = require("readline");
+
+const PACKAGE_NAME = "@superdoc-dev/visual-benchmarks";
+const CURRENT_VERSION = require("../package.json").version;
+const BIN_CACHE = path.join(__dirname, "..", ".bin-cache");
+const USER_CACHE_DIR = (() => {
+  const home = os.homedir();
+  if (!home) return BIN_CACHE;
+  const base =
+    process.env.XDG_CACHE_HOME ||
+    (process.platform === "darwin"
+      ? path.join(home, "Library", "Caches")
+      : path.join(home, ".cache"));
+  return path.join(base, "superdoc-benchmark");
+})();
+const CACHE_FILE = path.join(USER_CACHE_DIR, "update-check.json");
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const REGISTRY = (process.env.npm_config_registry || "https://registry.npmjs.org")
+  .replace(/\/$/, "");
+const PACKAGE_NAME_ENCODED = encodeURIComponent(PACKAGE_NAME);
+
+function getLatestVersion() {
+  return new Promise((resolve, reject) => {
+    const url = `${REGISTRY}/${PACKAGE_NAME_ENCODED}/latest`;
+    const client = url.startsWith("http:") ? http : https;
+    const req = client.get(
+      url,
+      { headers: { Accept: "application/json" } },
+      (res) => {
+        if (!res || res.statusCode < 200 || res.statusCode >= 300) {
+          res.resume();
+          reject(new Error("Failed to fetch npm metadata"));
+          return;
+        }
+
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(data).version);
+          } catch {
+            reject(new Error("Failed to parse npm response"));
+          }
+        });
+      }
+    );
+
+    req.setTimeout(2000, () => {
+      req.destroy(new Error("npm registry request timed out"));
+    });
+    req.on("error", reject);
+  });
+}
+
+function shouldCheckForUpdate() {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) return true;
+    const cache = JSON.parse(fs.readFileSync(CACHE_FILE, "utf8"));
+    return Date.now() - cache.lastCheck > CHECK_INTERVAL_MS;
+  } catch {
+    return true;
+  }
+}
+
+function cacheUpdateCheck(latestVersion) {
+  try {
+    fs.mkdirSync(USER_CACHE_DIR, { recursive: true });
+    fs.writeFileSync(
+      CACHE_FILE,
+      JSON.stringify({ lastCheck: Date.now(), latestVersion }),
+      "utf8"
+    );
+  } catch {
+    // Ignore cache write failures
+  }
+}
+
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] > pb[i]) return 1;
+    if (pa[i] < pb[i]) return -1;
+  }
+  return 0;
+}
+
+function isGlobalInstall() {
+  try {
+    const globalRoot = execSync("npm root -g", {
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+      .toString()
+      .trim();
+    return __dirname.startsWith(globalRoot);
+  } catch {
+    return false;
+  }
+}
+
+function promptForUpdate(latestVersion) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  return new Promise((resolve) => {
+    console.error(
+      `\nA new version of ${PACKAGE_NAME} is available: ${latestVersion} (current: ${CURRENT_VERSION})`
+    );
+    rl.question("   Would you like to update now? (Y/n) ", (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() !== "n");
+    });
+  });
+}
+
+function performUpdate() {
+  console.error(`\n   Updating ${PACKAGE_NAME}...`);
+  try {
+    execSync(`npm update -g ${PACKAGE_NAME}`, { stdio: "inherit" });
+    console.error("\n   Updated successfully. Please re-run your command.\n");
+    process.exit(0);
+  } catch {
+    console.error(
+      `\n   Update failed. Run manually: npm update -g ${PACKAGE_NAME}\n`
+    );
+  }
+}
+
+async function checkForUpdates() {
+  if (process.env.SUPERDOC_BENCHMARK_SKIP_UPDATE_CHECK === "1") return;
+  if (!process.stdin.isTTY || !process.stderr.isTTY) return;
+  if (!shouldCheckForUpdate()) return;
+
+  try {
+    const latestVersion = await getLatestVersion();
+    cacheUpdateCheck(latestVersion);
+
+    if (compareVersions(latestVersion, CURRENT_VERSION) > 0) {
+      if (!isGlobalInstall()) {
+        console.error(
+          `\nA new version of ${PACKAGE_NAME} is available: ${latestVersion} (current: ${CURRENT_VERSION})`
+        );
+        console.error(
+          "   Update with your package manager (e.g., npm update @superdoc-dev/visual-benchmarks).\n"
+        );
+        return;
+      }
+
+      const shouldUpdate = await promptForUpdate(latestVersion);
+      if (shouldUpdate) {
+        performUpdate();
+      } else {
+        console.error(
+          "   Skipped. Run `npm update -g @superdoc-dev/visual-benchmarks` anytime.\n"
+        );
+      }
+    }
+  } catch {
+    // Silently ignore update check failures
+  }
+}
+
+async function main() {
+  await checkForUpdates();
+
+  const binaryPath = path.join(BIN_CACHE, "superdoc-benchmark");
+
+  if (!fs.existsSync(binaryPath)) {
+    console.error("Binary not found. Try reinstalling:");
+    console.error(
+      "  npm uninstall -g @superdoc-dev/visual-benchmarks && npm install -g @superdoc-dev/visual-benchmarks"
+    );
+    process.exit(1);
+  }
+
+  const child = spawn(binaryPath, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  child.on("error", (err) => {
+    console.error(`Failed to run superdoc-benchmark: ${err.message}`);
+    process.exit(1);
+  });
+
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+
+main();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@superdoc-dev/visual-benchmarks",
+  "version": "0.2.8",
+  "description": "Visual comparison tool for SuperDoc document rendering",
+  "bin": {
+    "superdoc-benchmark": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "publish": "node scripts/publish.js"
+  },
+  "os": ["darwin"],
+  "cpu": ["arm64", "x64"],
+  "engines": {
+    "node": ">=16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/superdoc-dev/superdoc-visual-benchmarks"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "superdoc",
+    "benchmark",
+    "docx",
+    "word",
+    "visual-testing",
+    "document-comparison"
+  ],
+  "license": "MIT"
+}

package/scripts/postinstall.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const VERSION = require("../package.json").version;
+const REPO = "superdoc-dev/superdoc-visual-benchmarks";
+const LOCAL_TARBALL = process.env.SUPERDOC_BENCHMARK_BINARY_TARBALL;
+
+const platform = process.platform;
+const arch = process.arch;
+
+if (platform !== "darwin") {
+  console.error("superdoc-benchmark only supports macOS");
+  process.exit(1);
+}
+
+const archMap = { arm64: "arm64", x64: "x64" };
+const binaryArch = archMap[arch];
+
+if (!binaryArch) {
+  console.error(`Unsupported architecture: ${arch}`);
+  process.exit(1);
+}
+
+const binDir = path.join(__dirname, "..", ".bin-cache");
+const binaryPath = path.join(binDir, "superdoc-benchmark");
+
+const downloadUrl = `https://github.com/${REPO}/releases/download/v${VERSION}/superdoc-benchmark-darwin-${binaryArch}.tar.gz`;
+
+function extractTarball(tarballPath) {
+  execSync(`tar -xzf "${tarballPath}" -C "${binDir}"`, {
+    stdio: "inherit",
+  });
+}
+
+function download() {
+  if (fs.existsSync(binaryPath)) {
+    console.log("superdoc-benchmark binary already installed");
+    return;
+  }
+
+  console.log(
+    `Downloading superdoc-benchmark v${VERSION} for darwin-${binaryArch}...`
+  );
+
+  fs.mkdirSync(binDir, { recursive: true });
+
+  try {
+    if (LOCAL_TARBALL) {
+      const resolvedTarball = path.resolve(LOCAL_TARBALL);
+      if (!fs.existsSync(resolvedTarball)) {
+        throw new Error(`Local tarball not found: ${resolvedTarball}`);
+      }
+      extractTarball(resolvedTarball);
+    } else {
+      const tarPath = path.join(binDir, "download.tar.gz");
+      execSync(`curl -fsSL "${downloadUrl}" -o "${tarPath}"`, {
+        stdio: "inherit",
+      });
+      extractTarball(tarPath);
+      fs.unlinkSync(tarPath);
+    }
+
+    if (!fs.existsSync(binaryPath)) {
+      throw new Error("Binary was not found after extraction");
+    }
+
+    fs.chmodSync(binaryPath, 0o755);
+    console.log("superdoc-benchmark installed successfully");
+  } catch (err) {
+    console.error(`Failed to download binary: ${err.message}`);
+    console.error(`URL: ${downloadUrl}`);
+    console.error("\nYou can install from source instead:");
+    console.error(
+      "  git clone https://github.com/superdoc-dev/superdoc-visual-benchmarks"
+    );
+    console.error("  cd superdoc-visual-benchmarks && uv run superdoc-benchmark");
+    process.exit(1);
+  }
+}
+
+download();

package/scripts/publish.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const { execSync } = require("child_process");
+
+function isLifecycleFromPublish() {
+  const argv = process.env.npm_config_argv;
+  if (argv) {
+    try {
+      const parsed = JSON.parse(argv);
+      const original = parsed.original || [];
+      if (original[0] === "publish") {
+        return true;
+      }
+      if (original[0] === "run" || original[0] === "run-script") {
+        return false;
+      }
+    } catch {
+      // Fall through to npm_command check.
+    }
+  }
+
+  return process.env.npm_command === "publish";
+}
+
+if (isLifecycleFromPublish()) {
+  process.exit(0);
+}
+
+execSync("npm publish --access public", { stdio: "inherit" });