state-machine-cat 12.0.19 → 12.0.21

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016-2024 Sander Verweij
+Copyright (c) 2016-2025 Sander Verweij
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/cli/actions.mjs

@@ -5,7 +5,7 @@ const LICENSE = `
 
 The MIT License (MIT)
 
-Copyright (c) 2016-2024 Sander Verweij
+Copyright (c) 2016-2025 Sander Verweij
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

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 "neotraverse";
-import utl from "../../transform/utl.mjs";
+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,7 +16,6 @@ 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}`;
@@ -61,7 +60,13 @@ ${pIndent}    </table>`;
 	return `${pIndent}  "${pState.name}" [margin=0 class="${pState.class}" label= <${lLabelTag}
 ${pIndent}  >${pState.colorAttribute}${pState.fontColorAttribute}${lActiveAttribute}]${pState.noteText}`;
 }
-function compositeRegular(pState, pIndent, pOptions, pModel) {
+function compositeRegular(
+	pState,
+	pIndent,
+	pOptions,
+	pModel,
+	pRenderedTransitions,
+) {
 	const lPenWidth = pState.isParallelArea
 		? "1.0"
 		: pState.active
@@ -85,12 +90,18 @@ ${pIndent}    class="${pState.class}" label= <
 ${lLabelTag}
 ${pIndent}    > style=${lStyle} penwidth=${lPenWidth}${pState.colorAttribute}${pState.fontColorAttribute}
 ${pIndent}    "${pState.name}" [shape=point style=invis margin=0 width=0 height=0 fixedsize=true]
-${states(pState?.statemachine?.states ?? [], `${pIndent}    `, pOptions, pModel)}
+${states(pState?.statemachine?.states ?? [], `${pIndent}    `, pOptions, pModel, pRenderedTransitions)}
 ${pIndent}  }${pState.noteText}`;
 }
-function regular(pState, pIndent, pOptions, pModel) {
+function regular(pState, pIndent, pOptions, pModel, pRenderedTransitions) {
 	if (pState.statemachine) {
-		return compositeRegular(pState, pIndent, pOptions, pModel);
+		return compositeRegular(
+			pState,
+			pIndent,
+			pOptions,
+			pModel,
+			pRenderedTransitions,
+		);
 	}
 	return atomicRegular(pState, pIndent);
 }
@@ -163,14 +174,14 @@ const STATE_TYPE2FUNCTION = new Map([
 	["terminate", terminate],
 	["final", final],
 ]);
-function state(pState, pIndent, pOptions, pModel) {
+function state(pState, pIndent, pOptions, pModel, pRenderedTransitions) {
 	const lState = normalizeState(pState, pOptions, pIndent);
 	const lCandidateTransitions = pModel.findTransitionsToSiblings(
 		pState.name,
-		gRenderedTransitions,
+		pRenderedTransitions,
 	);
 	lCandidateTransitions.forEach((pTransition) => {
-		gRenderedTransitions.add(pTransition.id);
+		pRenderedTransitions.add(pTransition.id);
 	});
 	const lTransitions = transitions(
 		lCandidateTransitions,
@@ -184,14 +195,17 @@ function state(pState, pIndent, pOptions, pModel) {
 			pIndent,
 			pOptions,
 			pModel,
+			pRenderedTransitions,
 		) +
 		lTransitions +
 		"\n"
 	);
 }
-function states(pStates, pIndent, pOptions, pModel) {
+function states(pStates, pIndent, pOptions, pModel, pRenderedTransitions) {
 	return pStates
-		.map((pState) => state(pState, pIndent, pOptions, pModel))
+		.map((pState) =>
+			state(pState, pIndent, pOptions, pModel, pRenderedTransitions),
+		)
 		.join("");
 }
 function transition(pTransition, pIndent, pOptions, pModel) {
@@ -213,25 +227,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}]`;
 }
@@ -249,17 +270,22 @@ 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 lRenderedTransitions = new Set();
+	const lStates = states(
+		pStateMachine.states,
+		pIndent,
+		pOptions,
+		lModel,
+		lRenderedTransitions,
+	);
 	const lRemainingTransitions = transitions(
 		lModel.flattenedTransitions.filter(
-			(pTransition) => !gRenderedTransitions.has(pTransition.id),
+			(pTransition) => !lRenderedTransitions.has(pTransition.id),
 		),
 		pIndent,
 		pOptions,
 		lModel,
 	);
-	gRenderedTransitions = new Set();
 	return `digraph "state transitions" {
   ${lGraphAttributes}
   node [${lNodeAttributes}]

package/dist/state-machine-model.mjs

@@ -32,26 +32,26 @@ function flattenTransitions(pStateMachine) {
 	return lTransitions;
 }
 export default class StateMachineModel {
-	_flattenedTransitions;
-	_flattenedStates;
+	#flattenedTransitions;
+	#flattenedStates;
 	constructor(pStateMachine) {
-		this._flattenedStates = new Map();
-		flattenStatesToMap(pStateMachine.states ?? [], this._flattenedStates);
-		this._flattenedTransitions = flattenTransitions(pStateMachine);
+		this.#flattenedStates = new Map();
+		flattenStatesToMap(pStateMachine.states ?? [], this.#flattenedStates);
+		this.#flattenedTransitions = flattenTransitions(pStateMachine);
 	}
 	get flattenedTransitions() {
-		return this._flattenedTransitions;
+		return this.#flattenedTransitions;
 	}
 	findStateByName(pName) {
-		return this._flattenedStates.get(pName);
+		return this.#flattenedStates.get(pName);
 	}
 	findStatesByTypes(pTypes) {
-		return Array.from(this._flattenedStates.values()).filter((pState) =>
+		return Array.from(this.#flattenedStates.values()).filter((pState) =>
 			pTypes.includes(pState.type),
 		);
 	}
 	findExternalSelfTransitions(pStateName) {
-		return this._flattenedTransitions.filter(
+		return this.#flattenedTransitions.filter(
 			(pTransition) =>
 				pTransition.from === pStateName &&
 				pTransition.to === pStateName &&
@@ -59,22 +59,25 @@ export default class StateMachineModel {
 		);
 	}
 	findTransitionsByFrom(pFromStateName) {
-		return this._flattenedTransitions.filter(
+		return this.#flattenedTransitions.filter(
 			(pTransition) => pTransition.from === pFromStateName,
 		);
 	}
 	findTransitionsByTo(pToStateName) {
-		return this._flattenedTransitions.filter(
+		return this.#flattenedTransitions.filter(
 			(pTransition) => pTransition.to === pToStateName,
 		);
 	}
+	getMaximumTransitionId() {
+		return Math.max(...this.#flattenedTransitions.map(({ id }) => id));
+	}
 	findTransitionsToSiblings(pStateName, pExcludeIds) {
-		return this._flattenedTransitions.filter(
+		return this.#flattenedTransitions.filter(
 			(pTransition) =>
 				!pExcludeIds.has(pTransition.id) &&
 				pTransition.from === pStateName &&
-				this._flattenedStates.get(pTransition.to)?.parent ===
-					this._flattenedStates.get(pStateName)?.parent,
+				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.19";
+export const version = "12.0.21";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "state-machine-cat",
-	"version": "12.0.19",
+	"version": "12.0.21",
 	"description": "write beautiful state charts",
 	"main": "./dist/index.mjs",
 	"module": "./dist/index.mjs",

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.