state-machine-cat 12.0.13 → 12.0.15

package/dist/cli/cli.mjs

@@ -0,0 +1,170 @@
+import { readFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import satisfies from "semver/functions/satisfies.js";
+import { formatError, displayLicense, transform } from "./actions.mjs";
+import normalize from "./normalize.mjs";
+import validations from "./validations.mjs";
+const $package = JSON.parse(
+	readFileSync(new URL("../../package.json", import.meta.url), "utf8"),
+);
+const HELP_TEXT = `Usage: smcat [options] [infile]
+
+Write beautiful state charts - https://github.com/sverweij/state-machine-cat
+
+Options:
+  -T, --output-type <type>  ast|dot|eps|json|oldeps|oldps|oldps2|oldsvg|pdf|
+                            png|ps|ps2|scjson|scxml|smcat|svg
+                            (default: "svg")
+  -I, --input-type <type>   smcat|json|scxml (default: "smcat")
+  -E, --engine <type>       dot|circo|fdp|neato|osage|twopi (default: "dot")
+  -d, --direction <dir>     top-down|bottom-top|left-right|right-left (default:
+                            "top-down")
+  -o --output-to <file>     File to write to. use - for stdout.
+  --desugar                 transform pseudo states into transitions
+                            (!experimental!)
+  -V, --version             output the version number
+  -l, --license             Display license and exit
+  -h, --help                display help for command
+`;
+function presentError(pError, pErrorStream) {
+	pErrorStream.write(formatError(pError));
+	process.exitCode = 1;
+}
+function kebabToCamel(pString) {
+	return pString
+		.split("-")
+		.map((pWord, pIndex) =>
+			pIndex === 0
+				? pWord
+				: pWord.charAt(0).toUpperCase() + pWord.slice(1).toLowerCase(),
+		)
+		.join("");
+}
+function camelizeObject(pObject) {
+	const lNewObject = {};
+	for (const lKey in pObject) {
+		if (Object.hasOwn(pObject, lKey)) {
+			const camelCaseKey = kebabToCamel(lKey);
+			lNewObject[camelCaseKey] = pObject[lKey];
+		}
+	}
+	return lNewObject;
+}
+function parseArguments(pArguments) {
+	const lOptions = {
+		"output-type": {
+			type: "string",
+			short: "T",
+			default: validations.defaultOutputType,
+		},
+		"input-type": {
+			type: "string",
+			short: "I",
+			default: validations.defaultInputType,
+		},
+		engine: {
+			type: "string",
+			short: "E",
+			default: validations.defaultEngine,
+		},
+		direction: {
+			type: "string",
+			short: "d",
+			default: validations.defaultDirection,
+		},
+		"output-to": {
+			type: "string",
+			short: "o",
+		},
+		"dot-graph-attrs": {
+			type: "string",
+		},
+		"dot-node-attrs": {
+			type: "string",
+		},
+		"dot-edge-attrs": {
+			type: "string",
+		},
+		desugar: {
+			type: "boolean",
+			default: false,
+		},
+		license: {
+			type: "boolean",
+			short: "l",
+			default: false,
+		},
+		help: {
+			type: "boolean",
+			short: "h",
+			default: false,
+		},
+		version: {
+			type: "boolean",
+			short: "V",
+			default: false,
+		},
+	};
+	const { values, positionals } = parseArgs({
+		args: pArguments,
+		options: lOptions,
+		strict: true,
+		allowPositionals: true,
+		tokens: false,
+	});
+	values["output-type"] = validations.validOutputType(values["output-type"]);
+	values["input-type"] = validations.validInputType(values["input-type"]);
+	values.engine = validations.validEngine(values.engine);
+	values.direction = validations.validDirection(values.direction);
+	if (values["dot-graph-attrs"])
+		values["dot-graph-attrs"] = validations.validDotAttrs(
+			values["dot-graph-attrs"],
+		);
+	if (values["dot-node-attrs"])
+		values["dot-node-attrs"] = validations.validDotAttrs(
+			values["dot-node-attrs"],
+		);
+	if (values["dot-edge-attrs"])
+		values["dot-edge-attrs"] = validations.validDotAttrs(
+			values["dot-edge-attrs"],
+		);
+	return { values: camelizeObject(values), positionals };
+}
+function assertNodeVersion(pCurrentNodeVersion, pSupportedEngines) {
+	if (!satisfies(pCurrentNodeVersion, pSupportedEngines)) {
+		throw new Error(
+			`\nERROR: your node version (${pCurrentNodeVersion}) is not recent enough.\n` +
+				`       state-machine-cat is supported on node ${pSupportedEngines}\n\n`,
+		);
+	}
+}
+export default async function cli(pArguments = process.argv, pOptions) {
+	const lOptions = {
+		currentNodeVersion: process.versions.node,
+		supportedEngines: $package.engines.node,
+		outStream: process.stdout,
+		errorStream: process.stderr,
+		...pOptions,
+	};
+	try {
+		assertNodeVersion(lOptions.currentNodeVersion, lOptions.supportedEngines);
+		const { values, positionals } = parseArguments(pArguments.slice(2));
+		if (values.help) {
+			lOptions.outStream.write(HELP_TEXT, "utf8");
+			return;
+		}
+		if (values.version) {
+			lOptions.outStream.write(`${$package.version}\n`, "utf8");
+			return;
+		}
+		if (values.license) {
+			displayLicense(lOptions.outStream);
+			return;
+		}
+		await transform(
+			validations.validateArguments(normalize(positionals[0], values)),
+		);
+	} catch (pError) {
+		presentError(pError, lOptions.errorStream);
+	}
+}

package/dist/cli/main.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import cli from "./cli.mjs";
+await cli();

package/dist/render/dot/render-dot-from-ast.mjs

@@ -1,6 +1,6 @@
 import Handlebars from "handlebars/dist/handlebars.runtime.js";
-await import("./dot.template.js");
-await import("./dot.states.template.js");
+await import("./dot.template.cjs");
+await import("./dot.states.template.cjs");
 Handlebars.registerPartial(
 	"dot.states.template.hbs",
 	Handlebars.templates["dot.states.template.hbs"],

package/dist/render/smcat/index.mjs

@@ -1,5 +1,5 @@
 import Handlebars from "handlebars/dist/handlebars.runtime.js";
-await import("./smcat.template.js");
+await import("./smcat.template.cjs");
 const NAME_QUOTABLE = /;|,|{| |\[/;
 const ACTIONS_QUOTABLE = /;|,|{/;
 const LABEL_QUOTABLE = /;|{/;

package/dist/version.mjs

@@ -1 +1 @@
-export const version = "12.0.13";
+export const version = "12.0.15";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "state-machine-cat",
-	"version": "12.0.13",
+	"version": "12.0.15",
 	"description": "write beautiful state charts",
 	"main": "./dist/index.mjs",
 	"module": "./dist/index.mjs",
@@ -17,14 +17,11 @@
 		"#*": "./src/*"
 	},
 	"sideEffects": [
-		"dist/render/smcat/smcat.template.js",
-		"dist/render/dot/dot.states.template.js",
-		"dist/render/dot/dot.template.js",
-		"dist/render/scxml/scxml.states.template.js",
-		"dist/render/scxml/scxml.template.js"
+		"dist/render/smcat/smcat.template.cjs",
+		"dist/render/dot/dot.states.template.cjs",
+		"dist/render/dot/dot.template.cjs"
 	],
 	"files": [
-		"bin/",
 		"dist/",
 		"types/",
 		"package.json",
@@ -44,16 +41,13 @@
 	"author": "Sander Verweij",
 	"license": "MIT",
 	"bin": {
-		"smcat": "bin/smcat.mjs",
-		"sm-cat": "bin/smcat.mjs",
-		"sm_cat": "bin/smcat.mjs",
-		"state-machine-cat": "bin/smcat.mjs"
+		"smcat": "dist/cli/main.mjs",
+		"state-machine-cat": "dist/cli/main.mjs"
 	},
 	"dependencies": {
-		"@hpcc-js/wasm-graphviz": "1.2.0",
+		"@hpcc-js/wasm-graphviz": "1.5.0",
 		"ajv": "8.17.1",
-		"commander": "12.1.0",
-		"fast-xml-parser": "4.4.1",
+		"fast-xml-parser": "4.5.0",
 		"handlebars": "4.7.8",
 		"he": "1.2.0",
 		"semver": "^7.6.2",

package/bin/smcat.mjs

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// @ts-check
-import executeCommandLine from "../dist/cli/execute-command-line.mjs";
-
-await executeCommandLine();

package/dist/cli/execute-command-line.mjs

@@ -1,111 +0,0 @@
-import { readFileSync } from "node:fs";
-import { Command, Option } from "commander";
-import satisfies from "semver/functions/satisfies.js";
-import { formatError, displayLicense, transform } from "./actions.mjs";
-import normalize from "./normalize.mjs";
-import validations from "./validations.mjs";
-const $package = JSON.parse(
-	readFileSync(new URL("../../package.json", import.meta.url), "utf8"),
-);
-function presentError(pError, pErrorStream) {
-	pErrorStream.write(formatError(pError));
-	process.exitCode = 1;
-}
-function parseArguments(pArguments) {
-	return new Command()
-		.description(
-			"Write beautiful state charts - https://github.com/sverweij/state-machine-cat",
-		)
-		.option(
-			"-T, --output-type <type>",
-			validations.validOutputTypeRE,
-			validations.validOutputType,
-			validations.defaultOutputType,
-		)
-		.option(
-			"-I, --input-type <type>",
-			validations.validInputTypeRE,
-			validations.validInputType,
-			validations.defaultInputType,
-		)
-		.option(
-			"-E, --engine <type>",
-			validations.validEngineRE,
-			validations.validEngine,
-			validations.defaultEngine,
-		)
-		.option(
-			"-d, --direction <dir>",
-			validations.validDirectionRE,
-			validations.validDirection,
-			validations.defaultDirection,
-		)
-		.option("-o --output-to <file>", "File to write to. use - for stdout.")
-		.addOption(
-			new Option(
-				"--dot-graph-attrs <string>",
-				"graph attributes to pass to the dot render engine",
-			)
-				.argParser(validations.validDotAttrs)
-				.hideHelp(true),
-		)
-		.addOption(
-			new Option(
-				"--dot-node-attrs <string>",
-				"node attributes to pass to the dot render engine",
-			)
-				.argParser(validations.validDotAttrs)
-				.hideHelp(true),
-		)
-		.addOption(
-			new Option(
-				"--dot-edge-attrs <string>",
-				"edge attributes to pass to the dot render engine",
-			)
-				.argParser(validations.validDotAttrs)
-				.hideHelp(true),
-		)
-		.option(
-			"--desugar",
-			"transform pseudo states into transitions (!experimental!)",
-		)
-		.version($package.version)
-		.option("-l, --license", "Display license and exit")
-		.arguments("[infile]")
-		.parse(pArguments);
-}
-function assertNodeVersion(pCurrentNodeVersion, pSupportedEngines) {
-	if (!satisfies(pCurrentNodeVersion, pSupportedEngines)) {
-		throw new Error(
-			`\nERROR: your node version (${pCurrentNodeVersion}) is not recent enough.\n` +
-				`       state-machine-cat is supported on node ${pSupportedEngines}\n\n`,
-		);
-	}
-}
-export default async function executeCommandLine(
-	pArguments = process.argv,
-	pOptions,
-) {
-	const lOptions = {
-		currentNodeVersion: process.versions.node,
-		supportedEngines: $package.engines.node,
-		outStream: process.stdout,
-		errorStream: process.stderr,
-		...pOptions,
-	};
-	try {
-		assertNodeVersion(lOptions.currentNodeVersion, lOptions.supportedEngines);
-		const lProgram = parseArguments(pArguments);
-		if (lProgram.opts()?.license) {
-			displayLicense(lOptions.outStream);
-			return;
-		}
-		await transform(
-			validations.validateArguments(
-				normalize(lProgram.args[0], lProgram.opts()),
-			),
-		);
-	} catch (pError) {
-		presentError(pError, lOptions.errorStream);
-	}
-}