emf-converter 4.23.0 → 4.24.0

package/dist/cli.mjs

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+import { readFileSync } from 'fs';
+import * as fs from 'fs/promises';
+import { resolve, dirname, extname, basename, join, sep } from 'path';
+import { parseArgs } from 'util';
+import { convertMetafileToPdf, convertMetafile, loadSystemFonts } from './index.mjs';
+
+var CLI_FORMATS = [
+  { name: "png", extensions: [".png"] },
+  { name: "jpeg", extensions: [".jpg", ".jpeg"] },
+  { name: "webp", extensions: [".webp"] },
+  { name: "svg", extensions: [".svg"] },
+  { name: "pdf", extensions: [".pdf"] }
+];
+var INPUT_EXTENSIONS = [".emf", ".wmf", ".emz", ".wmz"];
+var OPTIONS = {
+  format: { type: "string", short: "f" },
+  out: { type: "string", short: "o" },
+  width: { type: "string" },
+  height: { type: "string" },
+  scale: { type: "string" },
+  quality: { type: "string" },
+  background: { type: "string" },
+  antialias: { type: "boolean" },
+  lossy: { type: "boolean" },
+  fonts: { type: "string" },
+  quiet: { type: "boolean", short: "q" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "v" }
+};
+var HELP_TEXT = `Usage: emf-converter <files...> [options]
+
+Convert EMF, EMF+, WMF and gzip-compressed (.emz, .wmz) metafiles to PNG,
+JPEG, WebP, SVG or PDF.
+
+Inputs:
+  <files...>            Files to convert. "-" reads one file from stdin.
+                        Wildcards (* and ?) are expanded by the CLI itself.
+
+Options:
+  -f, --format <fmt>    Output format: png, jpeg, webp, svg or pdf. Default:
+                        from the --out extension, else png.
+  -o, --out <path>      Output file for one input, or a directory (created if
+                        missing) for several. Default: next to each input,
+                        with the new extension. "-" writes to stdout.
+                        Stdin input without --out also writes to stdout.
+      --width <px>      Maximum output width in pixels.
+      --height <px>     Maximum output height in pixels.
+      --scale <n>       DPI scale factor (default 1; the library clamps to 4).
+      --quality <0-1>   JPEG quality (default 0.92), or lossy WebP quality
+                        (default 0.8).
+      --lossy           Lossy WebP instead of the default lossless WebP.
+      --background <c>  JPEG colour under transparent areas, #rgb or #rrggbb
+                        (default #ffffff). JPEG only.
+      --antialias       Smooth shape edges instead of reproducing Windows'
+                        own rasterisation.
+      --fonts <value>   "system" (default): the installed fonts, so text
+                        matches Windows; "none": no font files; or a
+                        directory of .ttf, .ttc, .fon or .fnt files.
+  -q, --quiet           Print only errors.
+  -h, --help            Show this help.
+  -v, --version         Print the version.
+
+Exit codes: 0 all files converted, 1 one or more files failed (the rest are
+still converted), 2 usage error.
+
+Examples:
+  emf-converter drawing.emf
+  emf-converter drawing.emf --width 1200 -o drawing.jpg
+  emf-converter "charts/*.wmf" -f svg -o out/
+  cat drawing.emz | emf-converter - -f png > drawing.png
+`;
+var UsageError = class extends Error {
+};
+async function main(argv, io) {
+  try {
+    return await run(argv, io);
+  } catch (err) {
+    if (err instanceof UsageError) {
+      io.stderr.write(`emf-converter: ${err.message}
+Try 'emf-converter --help' for more information.
+`);
+      return 2;
+    }
+    io.stderr.write(`emf-converter: ${describeError(err)}
+`);
+    return 1;
+  }
+}
+async function run(argv, io) {
+  const { values, positionals } = parseCommandLine(argv);
+  if (values.help) {
+    io.stdout.write(HELP_TEXT);
+    return 0;
+  }
+  if (values.version) {
+    io.stdout.write(`${readVersion()}
+`);
+    return 0;
+  }
+  if (positionals.length === 0) {
+    throw new UsageError("no input files given");
+  }
+  const quiet = values.quiet === true;
+  const toStdout = values.out === "-";
+  const outPath = values.out !== void 0 && !toStdout ? resolve(io.cwd, values.out) : void 0;
+  const format = chooseFormat(values.format, values.out);
+  const settings = convertSettings(values);
+  const fonts = chooseFonts(values.fonts ?? "system");
+  if (fonts.kind === "dir" && !await isDirectory(resolve(io.cwd, fonts.dir))) {
+    throw new UsageError(`--fonts: "${fonts.dir}" is not a directory`);
+  }
+  const jobs = await expandInputs(positionals, io.cwd);
+  const several = positionals.length > 1 || positionals.some((p) => /[*?]/.test(p));
+  const plans = await planOutputs(jobs, { format, outPath, toStdout, several});
+  let fontData;
+  const loadFonts = () => {
+    fontData ?? (fontData = fonts.kind === "none" ? Promise.resolve(void 0) : loadSystemFonts(fonts.kind === "dir" ? { dirs: [resolve(io.cwd, fonts.dir)] } : void 0));
+    return fontData;
+  };
+  let stdinData;
+  const readStdin = () => {
+    stdinData ?? (stdinData = collect(io.stdin));
+    return stdinData;
+  };
+  let failures = 0;
+  const fail = (label, message) => {
+    failures++;
+    io.stderr.write(`emf-converter: ${label}: ${message}
+`);
+  };
+  for (const plan of plans) {
+    const { job } = plan;
+    if (job.kind === "error") {
+      fail(job.label, job.message);
+      continue;
+    }
+    try {
+      const bytes = job.kind === "stdin" ? await readStdin() : await fs.readFile(job.path);
+      const fontList = await loadFonts();
+      const options = { ...settings, format, ...fontList ? { fonts: fontList } : {} };
+      const image = format === "pdf" ? await convertMetafileToPdf(bytes, options).then((data) => data && { data }) : await convertMetafile(bytes, options);
+      if (!image) {
+        fail(job.label, "not a readable EMF or WMF file, or the conversion failed");
+        continue;
+      }
+      if (plan.target === void 0) {
+        io.stdout.write(image.data);
+        continue;
+      }
+      await fs.mkdir(dirname(plan.target), { recursive: true });
+      await fs.writeFile(plan.target, image.data);
+      if (!quiet) {
+        io.stderr.write(`${job.label} -> ${plan.target}
+`);
+      }
+    } catch (err) {
+      fail(job.label, describeError(err));
+    }
+  }
+  return failures > 0 ? 1 : 0;
+}
+function parseCommandLine(argv) {
+  try {
+    const parsed = parseArgs({ args: [...argv], options: OPTIONS, allowPositionals: true, strict: true });
+    return { values: parsed.values, positionals: parsed.positionals };
+  } catch (err) {
+    throw new UsageError(describeError(err));
+  }
+}
+function chooseFormat(value, out) {
+  if (value !== void 0) {
+    const found = CLI_FORMATS.find((f) => f.name === value.toLowerCase());
+    if (!found) {
+      throw new UsageError(`unknown format "${value}" (use ${CLI_FORMATS.map((f) => f.name).join(", ")})`);
+    }
+    return found.name;
+  }
+  if (out !== void 0 && out !== "-") {
+    const ext = extname(out).toLowerCase();
+    const found = CLI_FORMATS.find((f) => f.extensions.includes(ext));
+    if (found) {
+      return found.name;
+    }
+  }
+  return "png";
+}
+function convertSettings(values) {
+  const settings = {};
+  if (values.width !== void 0) {
+    settings.maxWidth = parseNumber("width", values.width, (n) => n > 0, "a positive number");
+  }
+  if (values.height !== void 0) {
+    settings.maxHeight = parseNumber("height", values.height, (n) => n > 0, "a positive number");
+  }
+  if (values.scale !== void 0) {
+    settings.dpiScale = parseNumber("scale", values.scale, (n) => n > 0, "a positive number");
+  }
+  if (values.quality !== void 0) {
+    settings.quality = parseNumber("quality", values.quality, (n) => n >= 0 && n <= 1, "a number from 0 to 1");
+  }
+  if (values.background !== void 0) {
+    if (!/^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(values.background)) {
+      throw new UsageError(`--background needs #rgb or #rrggbb, not "${values.background}"`);
+    }
+    settings.background = values.background;
+  }
+  if (values.antialias) {
+    settings.gdiAntialias = true;
+  }
+  if (values.lossy) {
+    settings.lossless = false;
+  }
+  return settings;
+}
+function parseNumber(flag, raw, valid, expected) {
+  const n = raw.trim() === "" ? Number.NaN : Number(raw);
+  if (!Number.isFinite(n) || !valid(n)) {
+    throw new UsageError(`--${flag} needs ${expected}, not "${raw}"`);
+  }
+  return n;
+}
+function chooseFonts(value) {
+  if (value === "system" || value === "none") {
+    return { kind: value };
+  }
+  return { kind: "dir", dir: value };
+}
+async function expandInputs(args, cwd) {
+  const jobs = [];
+  for (const arg of args) {
+    if (arg === "-") {
+      jobs.push({ kind: "stdin", label: "stdin" });
+    } else if (/[*?]/.test(arg)) {
+      jobs.push(...await expandPattern(arg, cwd));
+    } else {
+      jobs.push(fileJob(arg, resolve(cwd, arg)));
+    }
+  }
+  return jobs;
+}
+async function expandPattern(pattern, cwd) {
+  if (typeof fs.glob !== "function") {
+    return [{ kind: "error", label: pattern, message: "wildcards need Node.js 22 or later, so the pattern was not expanded" }];
+  }
+  const globPattern = sep === "\\" ? pattern.replace(/\\/g, "/") : pattern;
+  const matches = [];
+  for await (const match of fs.glob(globPattern, { cwd })) {
+    if (INPUT_EXTENSIONS.includes(extname(match).toLowerCase())) {
+      matches.push(match);
+    }
+  }
+  if (matches.length === 0) {
+    return [{ kind: "error", label: pattern, message: "no .emf, .wmf, .emz or .wmz files match" }];
+  }
+  return matches.sort().map((match) => fileJob(match, resolve(cwd, match)));
+}
+function fileJob(label, path) {
+  return { kind: "file", label, path };
+}
+async function planOutputs(jobs, ctx) {
+  if (ctx.toStdout && jobs.length > 1) {
+    throw new UsageError('"-o -" writes one file to stdout, so give a single input');
+  }
+  const newExt = CLI_FORMATS.find((f) => f.name === ctx.format).extensions[0];
+  let outIsDirectory = false;
+  if (ctx.outPath !== void 0) {
+    const existing = await statOrNull(ctx.outPath);
+    if (ctx.several) {
+      if (existing && !existing.isDirectory()) {
+        throw new UsageError(`"${ctx.outPath}" is not a directory; several inputs need an output directory`);
+      }
+      outIsDirectory = true;
+    } else {
+      outIsDirectory = existing?.isDirectory() ?? false;
+    }
+  }
+  const plans = [];
+  const claimed = /* @__PURE__ */ new Map();
+  const inputPaths = new Set(jobs.flatMap((job) => job.kind === "file" ? [resolve(job.path)] : []));
+  for (const job of jobs) {
+    if (job.kind === "error" || ctx.toStdout || job.kind === "stdin" && ctx.outPath === void 0) {
+      plans.push({ job, target: void 0 });
+      continue;
+    }
+    let target;
+    if (ctx.outPath !== void 0) {
+      const stem = job.kind === "stdin" ? "stdin" : basename(job.path, extname(job.path));
+      target = outIsDirectory ? join(ctx.outPath, stem + newExt) : ctx.outPath;
+    } else if (job.kind === "file") {
+      target = join(dirname(job.path), basename(job.path, extname(job.path)) + newExt);
+    } else {
+      throw new Error("unreachable: stdin without --out goes to stdout");
+    }
+    const key = resolve(target);
+    if (inputPaths.has(key)) {
+      throw new UsageError(`the output "${target}" would overwrite an input file`);
+    }
+    const previous = claimed.get(key);
+    if (previous !== void 0) {
+      throw new UsageError(`"${previous}" and "${job.label}" would both write "${target}"`);
+    }
+    claimed.set(key, job.label);
+    plans.push({ job, target });
+  }
+  return plans;
+}
+async function statOrNull(path) {
+  return fs.stat(path).catch(() => null);
+}
+async function isDirectory(path) {
+  return (await statOrNull(path))?.isDirectory() ?? false;
+}
+async function collect(stream) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of stream) {
+    const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
+    chunks.push(bytes);
+    total += bytes.byteLength;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+function describeError(err) {
+  const code = err?.code;
+  if (code === "ENOENT") {
+    return "no such file or directory";
+  }
+  if (code === "EISDIR") {
+    return "is a directory";
+  }
+  return err instanceof Error ? err.message : String(err);
+}
+function readVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/cli-bin.ts
+main(process.argv.slice(2), {
+  stdout: process.stdout,
+  stderr: process.stderr,
+  stdin: process.stdin,
+  cwd: process.cwd()
+}).then((code) => {
+  process.exitCode = code;
+});