state-machine-cat 12.0.19 → 12.0.20

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

@@ -213,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}]`;
 }

package/dist/state-machine-model.mjs

@@ -68,6 +68,9 @@ 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) =>

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.20";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "state-machine-cat",
-	"version": "12.0.19",
+	"version": "12.0.20",
 	"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.