state-machine-cat 12.0.18 → 12.0.20

package/README.md

@@ -518,7 +518,7 @@ eat   -> sleep [color="blue" width=3.5] : belly full;
 
 ... would yield this diagram:
 
-<img width="659" alt="colored states and transitions" src="https://raw.githubusercontent.com/sverweij/state-machine-cat/main/docs/pics/10colored_states_and_transitions.png">
+<img width="488" alt="colored states and transitions" src="https://raw.githubusercontent.com/sverweij/state-machine-cat/main/docs/pics/10colored_states_and_transitions.png">
 
 What does 'experimental' mean?
 

package/dist/cli/cli.mjs

@@ -1,12 +1,8 @@
-import { readFileSync } from "node:fs";
 import { parseArgs } from "node:util";
-import satisfies from "semver/functions/satisfies.js";
+import { version } from "../version.mjs";
 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
@@ -130,31 +126,20 @@ function parseArguments(pArguments) {
 		);
 	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");
+			lOptions.outStream.write(`${version}\n`, "utf8");
 			return;
 		}
 		if (values.license) {

package/dist/counter.mjs

@@ -0,0 +1,9 @@
+export class Counter {
+	_lHWM = 0;
+	constructor(pStart = 0) {
+		this._lHWM = pStart;
+	}
+	next() {
+		return ++this._lHWM;
+	}
+}

package/dist/parse/index.mjs

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import options from "../options.mjs";
-import { parse as parseSmCat } from "./smcat/smcat-parser.mjs";
+import { parse as parseSmCat } from "./smcat/parse.mjs";
 import { parse as parseSCXML } from "./scxml/index.mjs";
 import $schema from "./smcat-ast.schema.mjs";
 const ajv = new Ajv();

package/dist/parse/parser-helpers.mjs

@@ -2,7 +2,6 @@ import StateMachineModel from "../state-machine-model.mjs";
 const TRIGGER_RE_AS_A_STRING =
 	"^(entry|activity|exit)\\s*/\\s*([^\\n$]*)(\\n|$)";
 const TRIGGER_RE = new RegExp(TRIGGER_RE_AS_A_STRING);
-let gTransitionIdHwm = 0;
 function stateExists(pKnownStateNames, pName) {
 	return pKnownStateNames.includes(pName);
 }
@@ -181,12 +180,6 @@ function extractActions(pString) {
 		.map((pActivityCandidate) => pActivityCandidate.trim())
 		.map(extractAction);
 }
-function nextTransitionId() {
-	return ++gTransitionIdHwm;
-}
-function resetTransitionId() {
-	gTransitionIdHwm = 0;
-}
 export default {
 	initState,
 	extractUndeclaredStates,
@@ -198,6 +191,4 @@ export default {
 	extractActions,
 	setIf,
 	setIfNotEmpty,
-	nextTransitionId,
-	resetTransitionId,
 };

package/dist/parse/scxml/index.mjs

@@ -1,8 +1,9 @@
 import fastxml from "fast-xml-parser";
 import he from "he";
-import traverse from "traverse";
-import utl from "../../transform/utl.mjs";
+import traverse from "neotraverse";
+import { Counter } from "../../counter.mjs";
 import parserHelpers from "../parser-helpers.mjs";
+import utl from "../../transform/utl.mjs";
 import { castArray } from "./utl.mjs";
 import { normalizeMachine } from "./normalize-machine.mjs";
 const formatLabel = utl.formatLabel;
@@ -97,12 +98,13 @@ function extractTransitionAttributes(pTransition) {
 	}
 	return lReturnValue;
 }
-function reduceTransition(pState) {
+function reduceTransition(pState, pCounter) {
 	return (pAllTransitions, pTransition) => {
 		const lTargets = (pTransition?.target ?? pState.id).split(/\s+/);
 		const lTransitionAttributes = extractTransitionAttributes(pTransition);
 		return pAllTransitions.concat(
 			lTargets.map((pTarget) => ({
+				id: pCounter.next(),
 				from: pState.id,
 				to: pTarget,
 				...lTransitionAttributes,
@@ -110,13 +112,13 @@ function reduceTransition(pState) {
 		);
 	};
 }
-function extractTransitions(pStates) {
+function extractTransitions(pStates, pCounter) {
 	return pStates
 		.filter((pState) => Object.hasOwn(pState, "transition"))
 		.reduce((pAllTransitions, pThisState) => {
 			const lTransitionAsArray = castArray(pThisState.transition);
 			return pAllTransitions.concat(
-				lTransitionAsArray.reduce(reduceTransition(pThisState), []),
+				lTransitionAsArray.reduce(reduceTransition(pThisState, pCounter), []),
 			);
 		}, []);
 }
@@ -130,9 +132,10 @@ function mapMachine(pSCXMLStateMachine) {
 			.concat(lNormalizedMachine.history.map(mapState("history")))
 			.concat(lNormalizedMachine.final.map(mapState("final"))),
 	};
-	const lTransitions = extractTransitions(lNormalizedMachine.initial)
-		.concat(extractTransitions(lNormalizedMachine.state))
-		.concat(extractTransitions(lNormalizedMachine.parallel));
+	const lCounter = new Counter();
+	const lTransitions = extractTransitions(lNormalizedMachine.initial, lCounter)
+		.concat(extractTransitions(lNormalizedMachine.state, lCounter))
+		.concat(extractTransitions(lNormalizedMachine.parallel, lCounter));
 	if (lTransitions.length > 0) {
 		lReturnValue.transitions = lTransitions;
 	}

package/dist/parse/smcat/parse.mjs

@@ -0,0 +1,5 @@
+import { Counter } from "../../counter.mjs";
+import { parse as pegParse } from "./smcat-parser.mjs";
+export function parse(pScript) {
+	return pegParse(pScript, { counter: new Counter() });
+}

package/dist/parse/smcat/smcat-parser.mjs

@@ -321,7 +321,6 @@ function peg$parse(input, options) {
 	var peg$e78 = peg$classExpectation(["\r", "\n"], true, false);
 	var peg$e79 = peg$otherExpectation("comment");
 	var peg$f0 = function (statemachine) {
-		parserHelpers.resetTransitionId();
 		statemachine.states = parserHelpers.extractUndeclaredStates(statemachine);
 		return parserHelpers.classifyForkJoins(statemachine);
 	};
@@ -431,7 +430,7 @@ function peg$parse(input, options) {
 			),
 		);
 		parserHelpers.setIfNotEmpty(trans, "note", notes);
-		trans.id = parserHelpers.nextTransitionId();
+		trans.id = options.counter.next();
 		return trans;
 	};
 	var peg$f20 = function (from_, to) {

package/dist/parse/smcat-ast.schema.mjs

@@ -122,7 +122,7 @@ export default {
 					type: "array",
 					items: {
 						type: "object",
-						required: ["from", "to"],
+						required: ["id", "from", "to"],
 						additionalProperties: false,
 						properties: {
 							id: {

package/dist/render/dot/index.mjs

@@ -16,6 +16,7 @@ import {
 	normalizeState,
 	stateNote,
 } from "./utl.mjs";
+let gRenderedTransitions = new Set();
 function initial(pState, pIndent) {
 	const lActiveAttribute = pState.active ? " penwidth=3.0" : "";
 	return `${pIndent}  "${pState.name}" [shape=circle style=filled class="${pState.class}" color="${pState.color}" fillcolor="${pState.color}" fixedsize=true height=0.15 label=""${lActiveAttribute}]${pState.noteText}`;
@@ -164,13 +165,28 @@ const STATE_TYPE2FUNCTION = new Map([
 ]);
 function state(pState, pIndent, pOptions, pModel) {
 	const lState = normalizeState(pState, pOptions, pIndent);
+	const lCandidateTransitions = pModel.findTransitionsToSiblings(
+		pState.name,
+		gRenderedTransitions,
+	);
+	lCandidateTransitions.forEach((pTransition) => {
+		gRenderedTransitions.add(pTransition.id);
+	});
+	const lTransitions = transitions(
+		lCandidateTransitions,
+		pIndent,
+		pOptions,
+		pModel,
+	);
 	return (
 		(STATE_TYPE2FUNCTION.get(pState.type) ?? regular)(
 			lState,
 			pIndent,
 			pOptions,
 			pModel,
-		) + "\n"
+		) +
+		lTransitions +
+		"\n"
 	);
 }
 function states(pStates, pIndent, pOptions, pModel) {
@@ -197,25 +213,32 @@ function transition(pTransition, pIndent, pOptions, pModel) {
 		? ` lhead="cluster_${pTransition.to}"`
 		: "";
 	const lTransitionName = `tr_${pTransition.from}_${pTransition.to}_${pTransition.id}`;
-	if (pTransition.note) {
-		const lNoteName = `note_${lTransitionName}`;
-		const lNoteNodeName = `i_${lNoteName}`;
-		const lNoteNode = `\n${pIndent}  "${lNoteNodeName}" [shape=point style=invis margin=0 width=0 height=0 fixedsize=true]`;
-		const lTransitionFrom = `\n${pIndent}  "${pTransition.from}" -> "${lNoteNodeName}" [arrowhead=none${lTail}${lColorAttribute}]`;
-		const lTransitionTo = `\n${pIndent}  "${lNoteNodeName}" -> "${pTransition.to}" [label="${lLabel}"${lHead}${lColorAttribute}${lFontColorAttribute}]`;
-		const lLineToNote = `\n${pIndent}  "${lNoteNodeName}" -> "${lNoteName}" [style=dashed arrowtail=none arrowhead=none weight=0]`;
-		const lNote = `\n${pIndent}  "${lNoteName}" [label="${noteToLabel(pTransition.note)}" shape=note fontsize=10 color=black fontcolor=black fillcolor="#ffffcc" penwidth=1.0]`;
-		return lNoteNode + lTransitionFrom + lTransitionTo + lLineToNote + lNote;
-	}
 	if (isCompositeSelf(pModel, pTransition)) {
 		const { lTailPorts, lHeadPorts } = getTransitionPorts(
 			pOptions,
 			pModel,
 			pTransition,
 		);
-		const lTransitionFrom = `\n${pIndent}  "${pTransition.from}" -> "self_tr_${pTransition.from}_${pTransition.to}_${pTransition.id}" [label="${lLabel}" arrowhead=none class="${lClass}"${lTailPorts}${lTail}${lColorAttribute}${lFontColorAttribute}]`;
+		let lNoteAndLine = "";
+		if (pTransition.note) {
+			const lNoteName = `note_${lTransitionName}`;
+			const lLineToNote = `\n${pIndent}  "${lNoteName}" -> "self_tr_${pTransition.from}_${pTransition.to}_${pTransition.id}" [style=dashed arrowtail=none arrowhead=none weight=0]`;
+			const lNote = `\n${pIndent}  "${lNoteName}" [label="${noteToLabel(pTransition.note)}" shape=note fontsize=10 color=black fontcolor=black fillcolor="#ffffcc" penwidth=1.0]`;
+			lNoteAndLine = lLineToNote + lNote;
+		}
+		const lTransitionFrom = `\n${pIndent}  "${pTransition.from}" -> "self_tr_${pTransition.from}_${pTransition.to}_${pTransition.id}" [label="${lLabel}" arrowhead=none class="${lClass}"${lTailPorts}${lTail}${lColorAttribute}${lFontColorAttribute}${lPenWidth}]`;
 		const lTransitionTo = `\n${pIndent}  "self_tr_${pTransition.from}_${pTransition.to}_${pTransition.id}" -> "${pTransition.to}" [class="${lClass}"${lHead}${lHeadPorts}${lColorAttribute}${lPenWidth}]`;
-		return lTransitionFrom + lTransitionTo;
+		return lTransitionFrom + lTransitionTo + lNoteAndLine;
+	}
+	if (pTransition.note) {
+		const lNoteName = `note_${lTransitionName}`;
+		const lNoteNodeName = `i_${lNoteName}`;
+		const lNoteNode = `\n${pIndent}  "${lNoteNodeName}" [shape=point style=invis margin=0 width=0 height=0 fixedsize=true]`;
+		const lTransitionFrom = `\n${pIndent}  "${pTransition.from}" -> "${lNoteNodeName}" [arrowhead=none${lTail}${lColorAttribute}${lPenWidth}]`;
+		const lTransitionTo = `\n${pIndent}  "${lNoteNodeName}" -> "${pTransition.to}" [label="${lLabel}"${lHead}${lColorAttribute}${lFontColorAttribute}${lPenWidth}]`;
+		const lLineToNote = `\n${pIndent}  "${lNoteNodeName}" -> "${lNoteName}" [style=dashed arrowtail=none arrowhead=none weight=0]`;
+		const lNote = `\n${pIndent}  "${lNoteName}" [label="${noteToLabel(pTransition.note)}" shape=note fontsize=10 color=black fontcolor=black fillcolor="#ffffcc" penwidth=1.0]`;
+		return lNoteNode + lTransitionFrom + lTransitionTo + lLineToNote + lNote;
 	}
 	return `\n${pIndent}  "${pTransition.from}" -> "${pTransition.to}" [label="${lLabel}" class="${lClass}"${lTail}${lHead}${lColorAttribute}${lFontColorAttribute}${lPenWidth}]`;
 }
@@ -233,19 +256,23 @@ export default function renderDot(pStateMachine, pOptions = {}, pIndent = "") {
 	const lNodeAttributes = buildNodeAttributes(pOptions.dotNodeAttrs || []);
 	const lEdgeAttributes = buildEdgeAttributes(pOptions.dotEdgeAttrs || []);
 	const lModel = new StateMachineModel(pStateMachine);
+	gRenderedTransitions = new Set();
 	const lStates = states(pStateMachine.states, pIndent, pOptions, lModel);
-	const lTransitions = transitions(
-		lModel.flattenedTransitions,
+	const lRemainingTransitions = transitions(
+		lModel.flattenedTransitions.filter(
+			(pTransition) => !gRenderedTransitions.has(pTransition.id),
+		),
 		pIndent,
 		pOptions,
 		lModel,
 	);
+	gRenderedTransitions = new Set();
 	return `digraph "state transitions" {
   ${lGraphAttributes}
   node [${lNodeAttributes}]
   edge [${lEdgeAttributes}]
 
-${lStates}${lTransitions}
+${lStates}${lRemainingTransitions}
 }
 `;
 }

package/dist/render/dot/utl.mjs

@@ -42,7 +42,8 @@ export function isVertical(pDirection) {
 export function isCompositeSelf(pStateMachineModel, pTransition) {
 	return (
 		pTransition.from === pTransition.to &&
-		pStateMachineModel.findStateByName(pTransition.from).statemachine &&
+		(pStateMachineModel.findStateByName(pTransition.from)?.statemachine ??
+			false) &&
 		pTransition.type !== "internal"
 	);
 }
@@ -94,7 +95,7 @@ export function getTransitionPorts(pOptions, pModel, pTransition) {
 	if (isVertical(lDirection)) {
 		lTailPorts = ' tailport="e" headport="e"';
 		lHeadPorts = ' tailport="w"';
-	} else if (pModel.findStateByName(pTransition.from).hasParent) {
+	} else if (pModel.findStateByName(pTransition.from)?.parent ?? false) {
 		lTailPorts = ' tailport="n" headport="n"';
 		lHeadPorts = ' tailport="s"';
 	}

package/dist/state-machine-model.mjs

@@ -1,21 +1,18 @@
-function flattenStates(pStates, pHasParent = false) {
-	let lReturnValue = [];
+function flattenStatesToMap(pStates, pMap, pParent = "") {
 	pStates
 		.filter((pState) => Boolean(pState.statemachine))
 		.forEach((pState) => {
 			if (Object.hasOwn(pState.statemachine, "states")) {
-				lReturnValue = lReturnValue.concat(
-					flattenStates(pState.statemachine.states, true),
-				);
+				flattenStatesToMap(pState.statemachine.states, pMap, pState.name);
 			}
 		});
-	return lReturnValue.concat(
-		pStates.map((pState) => ({
+	pStates.forEach((pState) =>
+		pMap.set(pState.name, {
 			name: pState.name,
 			type: pState.type,
 			statemachine: Boolean(pState.statemachine),
-			hasParent: pHasParent,
-		})),
+			parent: pParent,
+		}),
 	);
 }
 function flattenTransitions(pStateMachine) {
@@ -38,17 +35,18 @@ export default class StateMachineModel {
 	_flattenedTransitions;
 	_flattenedStates;
 	constructor(pStateMachine) {
-		this._flattenedStates = flattenStates(pStateMachine.states || []);
+		this._flattenedStates = new Map();
+		flattenStatesToMap(pStateMachine.states ?? [], this._flattenedStates);
 		this._flattenedTransitions = flattenTransitions(pStateMachine);
 	}
 	get flattenedTransitions() {
 		return this._flattenedTransitions;
 	}
 	findStateByName(pName) {
-		return this._flattenedStates.find((pState) => pState.name === pName);
+		return this._flattenedStates.get(pName);
 	}
 	findStatesByTypes(pTypes) {
-		return this._flattenedStates.filter((pState) =>
+		return Array.from(this._flattenedStates.values()).filter((pState) =>
 			pTypes.includes(pState.type),
 		);
 	}
@@ -70,4 +68,16 @@ export default class StateMachineModel {
 			(pTransition) => pTransition.to === pToStateName,
 		);
 	}
+	getMaximumTransitionId() {
+		return Math.max(...this._flattenedTransitions.map(({ id }) => id));
+	}
+	findTransitionsToSiblings(pStateName, pExcludeIds) {
+		return this._flattenedTransitions.filter(
+			(pTransition) =>
+				!pExcludeIds.has(pTransition.id) &&
+				pTransition.from === pStateName &&
+				this._flattenedStates.get(pTransition.to)?.parent ===
+					this._flattenedStates.get(pStateName)?.parent,
+		);
+	}
 }

package/dist/transform/desugar.mjs

@@ -1,16 +1,22 @@
 import StateMachineModel from "../state-machine-model.mjs";
+import { Counter } from "../counter.mjs";
 import utl from "./utl.mjs";
 function fuseTransitionAttribute(pIncomingThing, pOutgoingThing, pJoinChar) {
 	return pIncomingThing
 		? `${pIncomingThing}${pJoinChar}${pOutgoingThing}`
 		: pOutgoingThing;
 }
-function fuseIncomingToOutgoing(pIncomingTransition, pOutgoingTransition) {
+function fuseIncomingToOutgoing(
+	pIncomingTransition,
+	pOutgoingTransition,
+	pCounter,
+) {
 	const lReturnValue = {
 		...pIncomingTransition,
 		...pOutgoingTransition,
 		from: pIncomingTransition.from,
 		to: pOutgoingTransition.to,
+		id: pCounter.next(),
 	};
 	if (pOutgoingTransition.action) {
 		lReturnValue.action = fuseTransitionAttribute(
@@ -32,13 +38,14 @@ function fuseTransitions(
 	pTransitions,
 	pPseudoStateNames,
 	pOutgoingTransitionMap,
+	pCounter,
 ) {
 	return pTransitions.reduce((pAll, pTransition) => {
 		pPseudoStateNames.forEach((pStateName, pIndex) => {
 			if (pStateName === pTransition.to && pOutgoingTransitionMap[pStateName]) {
 				pAll = pAll.concat(
 					pOutgoingTransitionMap[pStateName].map((pOutgoingTransition) =>
-						fuseIncomingToOutgoing(pTransition, pOutgoingTransition),
+						fuseIncomingToOutgoing(pTransition, pOutgoingTransition, pCounter),
 					),
 				);
 			} else {
@@ -52,6 +59,7 @@ function deSugarPseudoStates(
 	pMachine,
 	pPseudoStateNames,
 	pOutgoingTransitionMap,
+	pCounter,
 ) {
 	const lMachine = structuredClone(pMachine);
 	if (lMachine.transitions && pPseudoStateNames.length > 0) {
@@ -59,6 +67,7 @@ function deSugarPseudoStates(
 			lMachine.transitions,
 			pPseudoStateNames,
 			pOutgoingTransitionMap,
+			pCounter,
 		);
 	}
 	lMachine.states = lMachine.states.map((pState) =>
@@ -69,6 +78,7 @@ function deSugarPseudoStates(
 						pState.statemachine,
 						pPseudoStateNames,
 						pOutgoingTransitionMap,
+						pCounter,
 					),
 				}
 			: pState,
@@ -117,10 +127,12 @@ export default (
 		},
 		{},
 	);
+	const lMaximumTransitionId = lModel.getMaximumTransitionId();
 	const lMachine = deSugarPseudoStates(
 		pMachine,
 		lPseudoStateNames,
 		lOutgoingTransitionMap,
+		new Counter(lMaximumTransitionId),
 	);
 	return removeStatesCascading(lMachine, lPseudoStateNames);
 };

package/dist/version.mjs

@@ -1 +1 @@
-export const version = "12.0.18";
+export const version = "12.0.20";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "state-machine-cat",
-	"version": "12.0.18",
+	"version": "12.0.20",
 	"description": "write beautiful state charts",
 	"main": "./dist/index.mjs",
 	"module": "./dist/index.mjs",
@@ -44,8 +44,7 @@
 		"ajv": "8.17.1",
 		"fast-xml-parser": "4.5.1",
 		"he": "1.2.0",
-		"semver": "^7.6.2",
-		"traverse": "0.6.8"
+		"neotraverse": "0.6.18"
 	},
 	"engines": {
 		"node": "^18.17||>=20"

package/types/state-machine-cat.d.mts

@@ -83,6 +83,10 @@ export interface IState {
 }
 
 export interface ITransition {
+	/**
+	 * The id of the transition. Unique within the root state machine.
+	 */
+	id: number;
 	/**
 	 * The name of the IState the transition is from
 	 */
@@ -91,10 +95,6 @@ export interface ITransition {
 	 * The name of the IState the transition is to
 	 */
 	to: string;
-	/**
-	 * The id of the transition. Unique within the root state machine.
-	 */
-	id: number;
 	/**
 	 * A display label to represent this transition. Parsers can parse this
 	 * label into events conditions and actions.