state-machine-cat 12.0.5 → 12.0.7

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

@@ -4,58 +4,108 @@ 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 $package = JSON.parse(
+	readFileSync(new URL("../../package.json", import.meta.url), "utf8"),
+);
 function presentError(pError, pErrorStream) {
-    pErrorStream.write(formatError(pError));
-    process.exitCode = 1;
+	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);
+	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`);
-    }
+	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);
-    }
+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);
+	}
 }

package/dist/cli/file-name-to-stream.mjs

@@ -1,13 +1,13 @@
 import fs from "node:fs";
 export function getOutStream(pOutputTo) {
-    if ("-" === pOutputTo) {
-        return process.stdout;
-    }
-    return fs.createWriteStream(pOutputTo);
+	if ("-" === pOutputTo) {
+		return process.stdout;
+	}
+	return fs.createWriteStream(pOutputTo);
 }
 export function getInStream(pInputFrom) {
-    if ("-" === pInputFrom) {
-        return process.stdin;
-    }
-    return fs.createReadStream(pInputFrom);
+	if ("-" === pInputFrom) {
+		return process.stdin;
+	}
+	return fs.createReadStream(pInputFrom);
 }

package/dist/cli/normalize.mjs

@@ -2,94 +2,113 @@ import path from "node:path";
 import options from "../options.mjs";
 import { parse as parseAttributes } from "./attributes-parser.mjs";
 const INPUT_EXTENSIONS = {
-    ".smcat": "smcat",
-    ".scxml": "scxml",
-    ".xml": "scxml",
-    ".json": "json",
-    ".ast": "json",
+	".smcat": "smcat",
+	".scxml": "scxml",
+	".xml": "scxml",
+	".json": "json",
+	".ast": "json",
 };
 const OUTPUT_EXTENSIONS = {
-    ".ast": "json",
-    ".dot": "dot",
-    ".eps": "eps",
-    ".json": "json",
-    ".pdf": "pdf",
-    ".png": "png",
-    ".ps": "ps",
-    ".ps2": "ps2",
-    ".scjson": "scjson",
-    ".scxml": "scxml",
-    ".smcat": "smcat",
-    ".svg": "svg",
+	".ast": "json",
+	".dot": "dot",
+	".eps": "eps",
+	".json": "json",
+	".pdf": "pdf",
+	".png": "png",
+	".ps": "ps",
+	".ps2": "ps2",
+	".scjson": "scjson",
+	".scxml": "scxml",
+	".smcat": "smcat",
+	".svg": "svg",
 };
 function classifyExtension(pString, pExtensionMap, pDefault) {
-    return pExtensionMap[path.extname(pString)] || pDefault;
+	return pExtensionMap[path.extname(pString)] || pDefault;
 }
 function outputType2Extension(pOutputType) {
-    const lExceptions = {
-        oldeps: "eps",
-        oldps: "ps",
-        oldps2: "ps",
-        oldsvg: "svg",
-        ps2: "ps",
-    };
-    return lExceptions[pOutputType] || pOutputType;
+	const lExceptions = {
+		oldeps: "eps",
+		oldps: "ps",
+		oldps2: "ps",
+		oldsvg: "svg",
+		ps2: "ps",
+	};
+	return lExceptions[pOutputType] || pOutputType;
 }
 function deriveOutputFromInput(pInputFrom, pOutputType) {
-    const lExtension = outputType2Extension(pOutputType);
-    if (!pInputFrom || "-" === pInputFrom) {
-        return "-";
-    }
-    return path
-        .join(path.dirname(pInputFrom), path.basename(pInputFrom, path.extname(pInputFrom)))
-        .concat(".")
-        .concat(lExtension);
+	const lExtension = outputType2Extension(pOutputType);
+	if (!pInputFrom || "-" === pInputFrom) {
+		return "-";
+	}
+	return path
+		.join(
+			path.dirname(pInputFrom),
+			path.basename(pInputFrom, path.extname(pInputFrom)),
+		)
+		.concat(".")
+		.concat(lExtension);
 }
 function determineOutputTo(pOutputTo, pInputFrom, pOutputType) {
-    return pOutputTo ? pOutputTo : deriveOutputFromInput(pInputFrom, pOutputType);
+	return pOutputTo ? pOutputTo : deriveOutputFromInput(pInputFrom, pOutputType);
 }
 function determineInputType(pInputFrom, pInputType) {
-    if (pInputType) {
-        return pInputType;
-    }
-    return classifyExtension(pInputFrom, INPUT_EXTENSIONS, options.getAllowedValues().inputType.default);
+	if (pInputType) {
+		return pInputType;
+	}
+	return classifyExtension(
+		pInputFrom,
+		INPUT_EXTENSIONS,
+		options.getAllowedValues().inputType.default,
+	);
 }
 function determineOutputType(pOutputTo, pOutputType) {
-    if (pOutputType) {
-        return pOutputType;
-    }
-    if (pOutputTo) {
-        return classifyExtension(pOutputTo, OUTPUT_EXTENSIONS, options.getAllowedValues().outputType.default);
-    }
-    return options.getAllowedValues().outputType.default;
+	if (pOutputType) {
+		return pOutputType;
+	}
+	if (pOutputTo) {
+		return classifyExtension(
+			pOutputTo,
+			OUTPUT_EXTENSIONS,
+			options.getAllowedValues().outputType.default,
+		);
+	}
+	return options.getAllowedValues().outputType.default;
 }
 function determineParameter(pOptions, pParameter) {
-    return Object.prototype.hasOwnProperty.call(pOptions, pParameter)
-        ?
-            pOptions[pParameter]
-        :
-            options.getAllowedValues()[pParameter].default;
+	return Object.prototype.hasOwnProperty.call(pOptions, pParameter)
+		? pOptions[pParameter]
+		: options.getAllowedValues()[pParameter].default;
 }
 function determineDotAttributes(pOptions, pDotAttributes) {
-    return Boolean(pOptions?.[pDotAttributes]) &&
-        typeof pOptions[pDotAttributes] === "string"
-        ? parseAttributes(pOptions[pDotAttributes])
-        : [];
+	return Boolean(pOptions?.[pDotAttributes]) &&
+		typeof pOptions[pDotAttributes] === "string"
+		? parseAttributes(pOptions[pDotAttributes])
+		: [];
 }
 export default function normalize(pArgument = "-", pLooseOptions = {}) {
-    const lNormalizedInputFrom = pArgument || "-";
-    const lNormalizedInputType = determineInputType(lNormalizedInputFrom, pLooseOptions.inputType);
-    const lNormalizedOutputType = determineOutputType(pLooseOptions.outputTo, pLooseOptions.outputType);
-    return {
-        inputFrom: lNormalizedInputFrom,
-        inputType: lNormalizedInputType,
-        outputType: lNormalizedOutputType,
-        outputTo: determineOutputTo(pLooseOptions.outputTo, lNormalizedInputFrom, lNormalizedOutputType),
-        engine: determineParameter(pLooseOptions, "engine"),
-        direction: determineParameter(pLooseOptions, "direction"),
-        dotGraphAttrs: determineDotAttributes(pLooseOptions, "dotGraphAttrs"),
-        dotNodeAttrs: determineDotAttributes(pLooseOptions, "dotNodeAttrs"),
-        dotEdgeAttrs: determineDotAttributes(pLooseOptions, "dotEdgeAttrs"),
-        desugar: pLooseOptions?.desugar ?? false,
-    };
+	const lNormalizedInputFrom = pArgument || "-";
+	const lNormalizedInputType = determineInputType(
+		lNormalizedInputFrom,
+		pLooseOptions.inputType,
+	);
+	const lNormalizedOutputType = determineOutputType(
+		pLooseOptions.outputTo,
+		pLooseOptions.outputType,
+	);
+	return {
+		inputFrom: lNormalizedInputFrom,
+		inputType: lNormalizedInputType,
+		outputType: lNormalizedOutputType,
+		outputTo: determineOutputTo(
+			pLooseOptions.outputTo,
+			lNormalizedInputFrom,
+			lNormalizedOutputType,
+		),
+		engine: determineParameter(pLooseOptions, "engine"),
+		direction: determineParameter(pLooseOptions, "direction"),
+		dotGraphAttrs: determineDotAttributes(pLooseOptions, "dotGraphAttrs"),
+		dotNodeAttrs: determineDotAttributes(pLooseOptions, "dotNodeAttrs"),
+		dotEdgeAttrs: determineDotAttributes(pLooseOptions, "dotEdgeAttrs"),
+		desugar: pLooseOptions?.desugar ?? false,
+	};
 }

package/dist/cli/validations.mjs

@@ -3,68 +3,88 @@ import smcat from "../index-node.mjs";
 import { parse as parseAttributes } from "./attributes-parser.mjs";
 const allowedValues = smcat.getAllowedValues();
 function getName(pValue) {
-    return pValue.name;
+	return pValue.name;
 }
 const VALID_OUTPUT_TYPES = allowedValues.outputType.values.map(getName);
 const VALID_INPUT_TYPES = allowedValues.inputType.values.map(getName);
 const VALID_ENGINES = allowedValues.engine.values.map(getName);
 const VALID_DIRECTIONS = allowedValues.direction.values.map(getName);
 function isStdout(pFilename) {
-    return "-" === pFilename;
+	return "-" === pFilename;
 }
 function fileExists(pFilename) {
-    try {
-        if (!isStdout(pFilename)) {
-            fs.accessSync(pFilename, fs.constants.R_OK);
-        }
-        return true;
-    }
-    catch (pError) {
-        return false;
-    }
+	try {
+		if (!isStdout(pFilename)) {
+			fs.accessSync(pFilename, fs.constants.R_OK);
+		}
+		return true;
+	} catch (pError) {
+		return false;
+	}
 }
 function validOption(pOption, pValidValues, pError) {
-    if (pValidValues.includes(pOption)) {
-        return pOption;
-    }
-    throw new Error(pError);
+	if (pValidValues.includes(pOption)) {
+		return pOption;
+	}
+	throw new Error(pError);
 }
 export default {
-    validOutputType: (pType) => validOption(pType, VALID_OUTPUT_TYPES, `\n  error: '${pType}' is not a valid output type. smcat can emit:` +
-        `\n          ${VALID_OUTPUT_TYPES.join(", ")}\n\n`),
-    validInputType: (pType) => validOption(pType, VALID_INPUT_TYPES, `\n  error: '${pType}' is not a valid input type.` +
-        `\n         smcat can read ${VALID_INPUT_TYPES.join(", ")}\n\n`),
-    validEngine: (pEngine) => validOption(pEngine, VALID_ENGINES, `\n  error: '${pEngine}' is not a valid input type.` +
-        `\n         you can choose from ${VALID_ENGINES.join(", ")}\n\n`),
-    validDirection: (pDirection) => validOption(pDirection, VALID_DIRECTIONS, `\n  error: '${pDirection}' is not a valid direction.` +
-        `\n         you can choose from ${VALID_DIRECTIONS.join(", ")}\n\n`),
-    validDotAttrs: (pDotAttributes) => {
-        try {
-            parseAttributes(pDotAttributes);
-            return pDotAttributes;
-        }
-        catch (pError) {
-            throw new Error(`Invalid dot attributes: ${pError.message}`);
-        }
-    },
-    validateArguments(pOptions) {
-        if (!pOptions.inputFrom) {
-            throw new Error(`\n  error: Please specify an input file.\n\n`);
-        }
-        if (!pOptions.outputTo) {
-            throw new Error(`\n  error: Please specify an output file.\n\n`);
-        }
-        if (!fileExists(pOptions.inputFrom)) {
-            throw new Error(`\n  error: Failed to open input file '${pOptions.inputFrom}'\n\n`);
-        }
-        return pOptions;
-    },
-    validOutputTypeRE: VALID_OUTPUT_TYPES.join("|"),
-    defaultOutputType: allowedValues.outputType.default,
-    validInputTypeRE: VALID_INPUT_TYPES.join("|"),
-    defaultInputType: allowedValues.inputType.default,
-    validEngineRE: VALID_ENGINES.join("|"),
-    defaultEngine: allowedValues.engine.default,
-    validDirectionRE: VALID_DIRECTIONS.join("|"),
-    defaultDirection: allowedValues.direction.default,
+	validOutputType: (pType) =>
+		validOption(
+			pType,
+			VALID_OUTPUT_TYPES,
+			`\n  error: '${pType}' is not a valid output type. smcat can emit:` +
+				`\n          ${VALID_OUTPUT_TYPES.join(", ")}\n\n`,
+		),
+	validInputType: (pType) =>
+		validOption(
+			pType,
+			VALID_INPUT_TYPES,
+			`\n  error: '${pType}' is not a valid input type.` +
+				`\n         smcat can read ${VALID_INPUT_TYPES.join(", ")}\n\n`,
+		),
+	validEngine: (pEngine) =>
+		validOption(
+			pEngine,
+			VALID_ENGINES,
+			`\n  error: '${pEngine}' is not a valid input type.` +
+				`\n         you can choose from ${VALID_ENGINES.join(", ")}\n\n`,
+		),
+	validDirection: (pDirection) =>
+		validOption(
+			pDirection,
+			VALID_DIRECTIONS,
+			`\n  error: '${pDirection}' is not a valid direction.` +
+				`\n         you can choose from ${VALID_DIRECTIONS.join(", ")}\n\n`,
+		),
+	validDotAttrs: (pDotAttributes) => {
+		try {
+			parseAttributes(pDotAttributes);
+			return pDotAttributes;
+		} catch (pError) {
+			throw new Error(`Invalid dot attributes: ${pError.message}`);
+		}
+	},
+	validateArguments(pOptions) {
+		if (!pOptions.inputFrom) {
+			throw new Error(`\n  error: Please specify an input file.\n\n`);
+		}
+		if (!pOptions.outputTo) {
+			throw new Error(`\n  error: Please specify an output file.\n\n`);
+		}
+		if (!fileExists(pOptions.inputFrom)) {
+			throw new Error(
+				`\n  error: Failed to open input file '${pOptions.inputFrom}'\n\n`,
+			);
+		}
+		return pOptions;
+	},
+	validOutputTypeRE: VALID_OUTPUT_TYPES.join("|"),
+	defaultOutputType: allowedValues.outputType.default,
+	validInputTypeRE: VALID_INPUT_TYPES.join("|"),
+	defaultInputType: allowedValues.inputType.default,
+	validEngineRE: VALID_ENGINES.join("|"),
+	defaultEngine: allowedValues.engine.default,
+	validDirectionRE: VALID_DIRECTIONS.join("|"),
+	defaultDirection: allowedValues.direction.default,
 };

package/dist/index-node.mjs

@@ -4,13 +4,16 @@ import desugar from "./transform/desugar.mjs";
 import getRenderFunction from "./render/index-node.mjs";
 import { version } from "./version.mjs";
 export default {
-    render(pScript, pOptions) {
-        const lStateMachine = parse.getAST(pScript, pOptions);
-        const lDesugar = options.getOptionValue(pOptions, "desugar");
-        return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(lDesugar ? desugar(lStateMachine) : lStateMachine, pOptions);
-    },
-    version,
-    getAllowedValues() {
-        return options.getAllowedValues();
-    },
+	render(pScript, pOptions) {
+		const lStateMachine = parse.getAST(pScript, pOptions);
+		const lDesugar = options.getOptionValue(pOptions, "desugar");
+		return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(
+			lDesugar ? desugar(lStateMachine) : lStateMachine,
+			pOptions,
+		);
+	},
+	version,
+	getAllowedValues() {
+		return options.getAllowedValues();
+	},
 };

package/dist/index.mjs

@@ -4,16 +4,19 @@ import desugar from "./transform/desugar.mjs";
 import getRenderFunction from "./render/index.mjs";
 import { version as _version } from "./version.mjs";
 export function render(pScript, pOptions) {
-    const lStateMachine = parse.getAST(pScript, pOptions);
-    const lDesugar = options.getOptionValue(pOptions, "desugar");
-    return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(lDesugar ? desugar(lStateMachine) : lStateMachine, pOptions);
+	const lStateMachine = parse.getAST(pScript, pOptions);
+	const lDesugar = options.getOptionValue(pOptions, "desugar");
+	return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(
+		lDesugar ? desugar(lStateMachine) : lStateMachine,
+		pOptions,
+	);
 }
 export const version = _version;
 export function getAllowedValues() {
-    return options.getAllowedValues();
+	return options.getAllowedValues();
 }
 export default {
-    render,
-    version,
-    getAllowedValues,
+	render,
+	version,
+	getAllowedValues,
 };