@hpcc-js/wasm-graphviz-cli 1.5.4 → 1.7.0

package/bin/index.js

@@ -2,35 +2,164 @@
 
 // src/main.ts
 import fs from "fs";
-import * as yargs from "yargs";
-import { hideBin } from "yargs/helpers";
 import { Graphviz } from "@hpcc-js/wasm-graphviz";
+
+// src/cliArgs.ts
+var HELP_TEXT = `Usage: dot-wasm [options] fileOrDot
+
+Options:
+  -K, --layout <engine>      Set layout engine (circo | dot | fdp | sfdp | neato |
+                             osage | patchwork | twopi | nop | nop2). Default: dot
+  -T, --format <format>      Set output format (svg | dot | json | dot_json |
+                             xdot_json | plain | plain-ext). Default: svg
+  -n, --neato-no-op <flag>   Set neato no-op flag (only valid with -K neato)
+  -y, --invert-y             Invert Y axis in plain/plain-ext formats
+  -v                         Echo GraphViz version
+  -h, --help                 Show this help message
+
+Examples:
+  dot-wasm -K neato -T xdot ./input.dot
+
+https://github.com/hpcc-systems/hpcc-js-wasm`;
+function parseArgs(args) {
+  const parsed = {
+    positional: []
+  };
+  const readValue = (flag, index) => {
+    if (index >= args.length) {
+      throw new Error(`${flag} option requires a value.`);
+    }
+    return args[index];
+  };
+  for (let i = 0; i < args.length; ++i) {
+    const token = args[i];
+    if (token === "--") {
+      parsed.positional.push(...args.slice(i + 1));
+      break;
+    }
+    if (token.startsWith("--")) {
+      const [rawName, maybeValue] = token.slice(2).split("=", 2);
+      i = handleOption(parsed, rawName, maybeValue ?? null, i, readValue);
+      continue;
+    }
+    if (token.startsWith("-") && token.length > 1) {
+      i = handleShortFlags(parsed, token.slice(1), i, readValue);
+      continue;
+    }
+    parsed.positional.push(token);
+  }
+  return parsed;
+}
+function handleOption(parsed, name, value, currentIndex, readValue) {
+  switch (name) {
+    case "layout":
+      parsed.layout = value ?? readValue("--layout", ++currentIndex);
+      return currentIndex;
+    case "format":
+      parsed.format = value ?? readValue("--format", ++currentIndex);
+      return currentIndex;
+    case "neato-no-op":
+      parsed.neatoNoOp = value ?? readValue("--neato-no-op", ++currentIndex);
+      return currentIndex;
+    case "invert-y":
+      parsed.invertY = true;
+      return currentIndex;
+    case "help":
+      parsed.help = true;
+      return currentIndex;
+    case "version":
+      parsed.version = true;
+      return currentIndex;
+    default:
+      throw new Error(`Unknown option --${name}`);
+  }
+}
+function handleShortFlags(parsed, flags, currentIndex, readValue) {
+  for (let j = 0; j < flags.length; ++j) {
+    const flag = flags[j];
+    switch (flag) {
+      case "K": {
+        const remaining = flags.slice(j + 1);
+        if (remaining) {
+          parsed.layout = remaining;
+          return currentIndex;
+        }
+        parsed.layout = readValue("-K", ++currentIndex);
+        return currentIndex;
+      }
+      case "T": {
+        const remaining = flags.slice(j + 1);
+        if (remaining) {
+          parsed.format = remaining;
+          return currentIndex;
+        }
+        parsed.format = readValue("-T", ++currentIndex);
+        return currentIndex;
+      }
+      case "n": {
+        const remaining = flags.slice(j + 1);
+        if (remaining) {
+          parsed.neatoNoOp = remaining;
+          return currentIndex;
+        }
+        parsed.neatoNoOp = readValue("-n", ++currentIndex);
+        return currentIndex;
+      }
+      case "y":
+        parsed.invertY = true;
+        break;
+      case "v":
+        parsed.version = true;
+        break;
+      case "h":
+        parsed.help = true;
+        break;
+      default:
+        throw new Error(`Unknown option -${flag}`);
+    }
+  }
+  return currentIndex;
+}
+
+// src/main.ts
 async function main() {
-  const myYargs = yargs.default(hideBin(process.argv));
-  myYargs.usage("Usage: dot-wasm [options] fileOrDot").demandCommand(0, 1).example("dot-wasm -K neato -T xdot ./input.dot", "Execute NEATO layout and outputs XDOT format.").alias("K", "layout").nargs("K", 1).describe("K", "Set layout engine (circo | dot | fdp | sfdp | neato | osage | patchwork | twopi | nop | nop2). By default, dot is used.").alias("T", "format").nargs("T", 1).describe("T", "Set output language to one of the supported formats (svg | dot | json | dot_json | xdot_json | plain | plain-ext). By default, svg is produced.").alias("n", "neato-no-op").nargs("n", 1).describe("n", 'Sets no-op flag in neato.  "-n 1" assumes neato nodes have already been positioned and all nodes have a pos attribute giving the positions. It then performs an optional adjustment to remove node-node overlap, depending on the value of the overlap attribute, computes the edge layouts, depending on the value of the splines attribute, and emits the graph in the appropriate format.\n"-n 2" Use node positions as specified, with no adjustment to remove node-node overlaps, and use any edge layouts already specified by the pos attribute. neato computes an edge layout for any edge that does not have a pos attribute. As usual, edge layout is guided by the splines attribute.').alias("y", "invert-y").nargs("y", 0).describe("y", "By default, the coordinate system used in generic output formats, such as attributed dot, extended dot, plain and plain-ext, is the standard cartesian system with the origin in the lower left corner, and with increasing y coordinates as points move from bottom to top. If the -y flag is used, the coordinate system is inverted, so that increasing values of y correspond to movement from top to bottom.").nargs("v", 0).describe("v", "Echo GraphViz library version").help("h").alias("h", "help").epilog("https://github.com/hpcc-systems/hpcc-js-wasm");
-  const argv = await myYargs.argv;
   try {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (parsed.help) {
+      console.log(HELP_TEXT);
+      return;
+    }
+    if (parsed.positional.length > 1) {
+      throw new Error("Only one 'fileOrDot' argument is allowed.");
+    }
     let dot;
-    if (fs.existsSync(argv._[0])) {
-      dot = fs.readFileSync(argv._[0], "utf8");
-    } else {
-      dot = argv._[0];
+    const fileOrDot = parsed.positional[0];
+    if (fileOrDot) {
+      if (fs.existsSync(fileOrDot)) {
+        dot = fs.readFileSync(fileOrDot, "utf8");
+      } else {
+        dot = fileOrDot;
+      }
     }
     const graphviz = await Graphviz.load();
-    if (argv.v) {
+    if (parsed.version) {
       console.log(`GraphViz version:  ${graphviz.version()}`);
-    } else if (dot) {
-      if (argv.n && argv.layout.trim() !== "neato") {
-        throw new Error("-n option is only supported with -T neato");
+      return;
+    }
+    if (dot) {
+      const layout = (parsed.layout ?? "dot").trim();
+      const format = (parsed.format ?? "svg").trim();
+      if (parsed.neatoNoOp && layout !== "neato") {
+        throw new Error("-n option is only supported with -K neato");
       }
       const ext = {};
-      if (argv.n) {
-        ext.nop = parseInt(argv.n);
+      if (parsed.neatoNoOp) {
+        ext.nop = parseInt(parsed.neatoNoOp, 10);
       }
-      if (argv.y) {
+      if (parsed.invertY) {
         ext.yInvert = true;
       }
-      const response = graphviz.layout(dot, argv.format?.trim() ?? "svg", argv.layout?.trim() ?? "dot", ext);
+      const response = graphviz.layout(dot, format, layout, ext);
       console.log(response);
     } else {
       throw new Error("'fileOrDot' is required.");
@@ -38,7 +167,7 @@ async function main() {
   } catch (e) {
     console.error(`Error:  ${e?.message}
 `);
-    myYargs.showHelp();
+    console.error(HELP_TEXT);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hpcc-js/wasm-graphviz-cli",
-  "version": "1.5.4",
+  "version": "1.7.0",
   "description": "hpcc-js - WASM Graphviz Cli",
   "type": "module",
   "bin": {
@@ -31,13 +31,13 @@
     "lint-skypack": "npx -y @skypack/package-check",
     "lint-eslint": "eslint src/**/*.ts",
     "lint": "run-p lint-eslint",
-    "test": "node bin/index.js --help",
+    "test:unit": "vitest run",
+    "test": "npm run test:unit && node bin/index.js --help",
     "update": "npx -y npm-check-updates -u -t minor",
     "update-major": "npx -y npm-check-updates -u"
   },
   "dependencies": {
-    "@hpcc-js/wasm-graphviz": "^1.13.0",
-    "yargs": "18.0.0"
+    "@hpcc-js/wasm-graphviz": "^1.16.0"
   },
   "keywords": [
     "graphviz",
@@ -55,5 +55,5 @@
   },
   "homepage": "https://hpcc-systems.github.io/hpcc-js-wasm/",
   "license": "Apache-2.0",
-  "gitHead": "adbfa7aea45d38911cd2109336c471cfd5142ddd"
+  "gitHead": "3fa48df3d5a7a6c43bf4f0c8839f1f9df27080da"
 }

package/src/cliArgs.ts

@@ -0,0 +1,136 @@
+export interface ParsedArgs {
+    layout?: string;
+    format?: string;
+    neatoNoOp?: string;
+    invertY?: boolean;
+    version?: boolean;
+    help?: boolean;
+    positional: string[];
+}
+
+export const HELP_TEXT = `Usage: dot-wasm [options] fileOrDot
+
+Options:
+  -K, --layout <engine>      Set layout engine (circo | dot | fdp | sfdp | neato |
+                             osage | patchwork | twopi | nop | nop2). Default: dot
+  -T, --format <format>      Set output format (svg | dot | json | dot_json |
+                             xdot_json | plain | plain-ext). Default: svg
+  -n, --neato-no-op <flag>   Set neato no-op flag (only valid with -K neato)
+  -y, --invert-y             Invert Y axis in plain/plain-ext formats
+  -v                         Echo GraphViz version
+  -h, --help                 Show this help message
+
+Examples:
+  dot-wasm -K neato -T xdot ./input.dot
+
+https://github.com/hpcc-systems/hpcc-js-wasm`;
+
+export function parseArgs(args: string[]): ParsedArgs {
+    const parsed: ParsedArgs = {
+        positional: []
+    };
+
+    const readValue = (flag: string, index: number): string => {
+        if (index >= args.length) {
+            throw new Error(`${flag} option requires a value.`);
+        }
+        return args[index];
+    };
+
+    for (let i = 0; i < args.length; ++i) {
+        const token = args[i];
+
+        if (token === "--") {
+            parsed.positional.push(...args.slice(i + 1));
+            break;
+        }
+
+        if (token.startsWith("--")) {
+            const [rawName, maybeValue] = token.slice(2).split("=", 2);
+            i = handleOption(parsed, rawName, maybeValue ?? null, i, readValue);
+            continue;
+        }
+
+        if (token.startsWith("-") && token.length > 1) {
+            i = handleShortFlags(parsed, token.slice(1), i, readValue);
+            continue;
+        }
+
+        parsed.positional.push(token);
+    }
+
+    return parsed;
+}
+
+function handleOption(parsed: ParsedArgs, name: string, value: string | null, currentIndex: number, readValue: (flag: string, index: number) => string): number {
+    switch (name) {
+        case "layout":
+            parsed.layout = value ?? readValue("--layout", ++currentIndex);
+            return currentIndex;
+        case "format":
+            parsed.format = value ?? readValue("--format", ++currentIndex);
+            return currentIndex;
+        case "neato-no-op":
+            parsed.neatoNoOp = value ?? readValue("--neato-no-op", ++currentIndex);
+            return currentIndex;
+        case "invert-y":
+            parsed.invertY = true;
+            return currentIndex;
+        case "help":
+            parsed.help = true;
+            return currentIndex;
+        case "version":
+            parsed.version = true;
+            return currentIndex;
+        default:
+            throw new Error(`Unknown option --${name}`);
+    }
+}
+
+function handleShortFlags(parsed: ParsedArgs, flags: string, currentIndex: number, readValue: (flag: string, index: number) => string): number {
+    for (let j = 0; j < flags.length; ++j) {
+        const flag = flags[j];
+        switch (flag) {
+            case "K": {
+                const remaining = flags.slice(j + 1);
+                if (remaining) {
+                    parsed.layout = remaining;
+                    return currentIndex;
+                }
+                parsed.layout = readValue("-K", ++currentIndex);
+                return currentIndex;
+            }
+            case "T": {
+                const remaining = flags.slice(j + 1);
+                if (remaining) {
+                    parsed.format = remaining;
+                    return currentIndex;
+                }
+                parsed.format = readValue("-T", ++currentIndex);
+                return currentIndex;
+            }
+            case "n": {
+                const remaining = flags.slice(j + 1);
+                if (remaining) {
+                    parsed.neatoNoOp = remaining;
+                    return currentIndex;
+                }
+                parsed.neatoNoOp = readValue("-n", ++currentIndex);
+                return currentIndex;
+            }
+            case "y":
+                parsed.invertY = true;
+                break;
+            case "v":
+                parsed.version = true;
+                break;
+            case "h":
+                parsed.help = true;
+                break;
+            default:
+                throw new Error(`Unknown option -${flag}`);
+        }
+    }
+
+    return currentIndex;
+}

package/src/main.ts

@@ -1,69 +1,63 @@
 import fs from "fs";
-import * as yargs from "yargs";
-import { hideBin } from "yargs/helpers";
 import { Graphviz, Engine, Format, Options } from "@hpcc-js/wasm-graphviz";
+import { HELP_TEXT, parseArgs } from "./cliArgs.ts";
 
 export async function main() {
 
-    const myYargs = yargs.default(hideBin(process.argv)) as yargs.Argv<{ vx: boolean, layout: Engine, format: Format, n: string }>;
-    myYargs
-        .usage("Usage: dot-wasm [options] fileOrDot")
-        .demandCommand(0, 1)
-        .example("dot-wasm -K neato -T xdot ./input.dot", "Execute NEATO layout and outputs XDOT format.")
-        .alias("K", "layout")
-        .nargs("K", 1)
-        .describe("K", "Set layout engine (circo | dot | fdp | sfdp | neato | osage | patchwork | twopi | nop | nop2). By default, dot is used.")
-        .alias("T", "format")
-        .nargs("T", 1)
-        .describe("T", "Set output language to one of the supported formats (svg | dot | json | dot_json | xdot_json | plain | plain-ext). By default, svg is produced.")
-        .alias("n", "neato-no-op")
-        .nargs("n", 1)
-        .describe("n", "Sets no-op flag in neato.  \"-n 1\" assumes neato nodes have already been positioned and all nodes have a pos attribute giving the positions. It then performs an optional adjustment to remove node-node overlap, depending on the value of the overlap attribute, computes the edge layouts, depending on the value of the splines attribute, and emits the graph in the appropriate format.\n\"-n 2\" Use node positions as specified, with no adjustment to remove node-node overlaps, and use any edge layouts already specified by the pos attribute. neato computes an edge layout for any edge that does not have a pos attribute. As usual, edge layout is guided by the splines attribute.")
-        .alias("y", "invert-y")
-        .nargs("y", 0)
-        .describe("y", "By default, the coordinate system used in generic output formats, such as attributed dot, extended dot, plain and plain-ext, is the standard cartesian system with the origin in the lower left corner, and with increasing y coordinates as points move from bottom to top. If the -y flag is used, the coordinate system is inverted, so that increasing values of y correspond to movement from top to bottom.")
-        .nargs("v", 0)
-        .describe("v", "Echo GraphViz library version")
-        .help("h")
-        .alias("h", "help")
-        .epilog("https://github.com/hpcc-systems/hpcc-js-wasm")
-        ;
+    try {
+        const parsed = parseArgs(process.argv.slice(2));
 
-    const argv = await myYargs.argv;
+        if (parsed.help) {
+            console.log(HELP_TEXT);
+            return;
+        }
 
-    try {
-        let dot;
-        if (fs.existsSync(argv._[0] as string)) {
-            dot = fs.readFileSync(argv._[0], "utf8");
-        } else {
-            dot = argv._[0] as string;
+        if (parsed.positional.length > 1) {
+            throw new Error("Only one 'fileOrDot' argument is allowed.");
         }
+
+        let dot: string | undefined;
+        const fileOrDot = parsed.positional[0];
+        if (fileOrDot) {
+            if (fs.existsSync(fileOrDot)) {
+                dot = fs.readFileSync(fileOrDot, "utf8");
+            } else {
+                dot = fileOrDot;
+            }
+        }
+
         const graphviz = await Graphviz.load();
 
-        if (argv.v) {
+        if (parsed.version) {
             console.log(`GraphViz version:  ${graphviz.version()}`);
-        } else if (dot) {
+            return;
+        }
+
+        if (dot) {
+
+            const layout = (parsed.layout ?? "dot").trim();
+            const format = (parsed.format ?? "svg").trim();
 
-            if (argv.n && argv.layout.trim() !== "neato") {
-                throw new Error("-n option is only supported with -T neato");
+            if (parsed.neatoNoOp && layout !== "neato") {
+                throw new Error("-n option is only supported with -K neato");
             }
 
             const ext: Options = {
             };
-            if (argv.n) {
-                ext.nop = parseInt(argv.n);
+            if (parsed.neatoNoOp) {
+                ext.nop = parseInt(parsed.neatoNoOp, 10);
             }
-            if (argv.y) {
+            if (parsed.invertY) {
                 ext.yInvert = true;
             }
 
-            const response = graphviz.layout(dot, (argv.format?.trim() ?? "svg") as Format, (argv.layout?.trim() ?? "dot") as Engine, ext);
+            const response = graphviz.layout(dot, format as Format, layout as Engine, ext);
             console.log(response);
         } else {
             throw new Error("'fileOrDot' is required.");
         }
     } catch (e: any) {
         console.error(`Error:  ${e?.message}\n`);
-        myYargs.showHelp();
+        console.error(HELP_TEXT);
     }
-}
+}

package/types/cliArgs.d.ts

@@ -0,0 +1,11 @@
+export interface ParsedArgs {
+    layout?: string;
+    format?: string;
+    neatoNoOp?: string;
+    invertY?: boolean;
+    version?: boolean;
+    help?: boolean;
+    positional: string[];
+}
+export declare const HELP_TEXT = "Usage: dot-wasm [options] fileOrDot\n\nOptions:\n  -K, --layout <engine>      Set layout engine (circo | dot | fdp | sfdp | neato |\n                             osage | patchwork | twopi | nop | nop2). Default: dot\n  -T, --format <format>      Set output format (svg | dot | json | dot_json |\n                             xdot_json | plain | plain-ext). Default: svg\n  -n, --neato-no-op <flag>   Set neato no-op flag (only valid with -K neato)\n  -y, --invert-y             Invert Y axis in plain/plain-ext formats\n  -v                         Echo GraphViz version\n  -h, --help                 Show this help message\n\nExamples:\n  dot-wasm -K neato -T xdot ./input.dot\n\nhttps://github.com/hpcc-systems/hpcc-js-wasm";
+export declare function parseArgs(args: string[]): ParsedArgs;