state-machine-cat 12.0.5 → 12.0.7

package/dist/state-machine-model.mjs

@@ -1,58 +1,73 @@
 function flattenStates(pStates, pHasParent = false) {
-    let lReturnValue = [];
-    pStates
-        .filter((pState) => Boolean(pState.statemachine))
-        .forEach((pState) => {
-        if (Object.prototype.hasOwnProperty.call(pState.statemachine, "states")) {
-            lReturnValue = lReturnValue.concat(flattenStates(pState.statemachine.states, true));
-        }
-    });
-    return lReturnValue.concat(pStates.map((pState) => ({
-        name: pState.name,
-        type: pState.type,
-        statemachine: Boolean(pState.statemachine),
-        hasParent: pHasParent,
-    })));
+	let lReturnValue = [];
+	pStates
+		.filter((pState) => Boolean(pState.statemachine))
+		.forEach((pState) => {
+			if (Object.prototype.hasOwnProperty.call(pState.statemachine, "states")) {
+				lReturnValue = lReturnValue.concat(
+					flattenStates(pState.statemachine.states, true),
+				);
+			}
+		});
+	return lReturnValue.concat(
+		pStates.map((pState) => ({
+			name: pState.name,
+			type: pState.type,
+			statemachine: Boolean(pState.statemachine),
+			hasParent: pHasParent,
+		})),
+	);
 }
 function flattenTransitions(pStateMachine) {
-    let lTransitions = [];
-    if (Object.prototype.hasOwnProperty.call(pStateMachine, "transitions")) {
-        lTransitions = pStateMachine.transitions;
-    }
-    if (Object.prototype.hasOwnProperty.call(pStateMachine, "states")) {
-        pStateMachine.states
-            .filter((pState) => Boolean(pState.statemachine))
-            .forEach((pState) => {
-            lTransitions = lTransitions.concat(flattenTransitions(pState.statemachine));
-        });
-    }
-    return lTransitions;
+	let lTransitions = [];
+	if (Object.prototype.hasOwnProperty.call(pStateMachine, "transitions")) {
+		lTransitions = pStateMachine.transitions;
+	}
+	if (Object.prototype.hasOwnProperty.call(pStateMachine, "states")) {
+		pStateMachine.states
+			.filter((pState) => Boolean(pState.statemachine))
+			.forEach((pState) => {
+				lTransitions = lTransitions.concat(
+					flattenTransitions(pState.statemachine),
+				);
+			});
+	}
+	return lTransitions;
 }
 export default class StateMachineModel {
-    _flattenedTransitions;
-    _flattenedStates;
-    constructor(pStateMachine) {
-        this._flattenedStates = flattenStates(pStateMachine.states || []);
-        this._flattenedTransitions = flattenTransitions(pStateMachine);
-    }
-    get flattenedTransitions() {
-        return this._flattenedTransitions;
-    }
-    findStateByName(pName) {
-        return this._flattenedStates.find((pState) => pState.name === pName);
-    }
-    findStatesByTypes(pTypes) {
-        return this._flattenedStates.filter((pState) => pTypes.includes(pState.type));
-    }
-    findExternalSelfTransitions(pStateName) {
-        return this._flattenedTransitions.filter((pTransition) => pTransition.from === pStateName &&
-            pTransition.to === pStateName &&
-            pTransition.type !== "internal");
-    }
-    findTransitionsByFrom(pFromStateName) {
-        return this._flattenedTransitions.filter((pTransition) => pTransition.from === pFromStateName);
-    }
-    findTransitionsByTo(pToStateName) {
-        return this._flattenedTransitions.filter((pTransition) => pTransition.to === pToStateName);
-    }
+	_flattenedTransitions;
+	_flattenedStates;
+	constructor(pStateMachine) {
+		this._flattenedStates = flattenStates(pStateMachine.states || []);
+		this._flattenedTransitions = flattenTransitions(pStateMachine);
+	}
+	get flattenedTransitions() {
+		return this._flattenedTransitions;
+	}
+	findStateByName(pName) {
+		return this._flattenedStates.find((pState) => pState.name === pName);
+	}
+	findStatesByTypes(pTypes) {
+		return this._flattenedStates.filter((pState) =>
+			pTypes.includes(pState.type),
+		);
+	}
+	findExternalSelfTransitions(pStateName) {
+		return this._flattenedTransitions.filter(
+			(pTransition) =>
+				pTransition.from === pStateName &&
+				pTransition.to === pStateName &&
+				pTransition.type !== "internal",
+		);
+	}
+	findTransitionsByFrom(pFromStateName) {
+		return this._flattenedTransitions.filter(
+			(pTransition) => pTransition.from === pFromStateName,
+		);
+	}
+	findTransitionsByTo(pToStateName) {
+		return this._flattenedTransitions.filter(
+			(pTransition) => pTransition.to === pToStateName,
+		);
+	}
 }

package/dist/transform/desugar.mjs

@@ -1,77 +1,126 @@
 import StateMachineModel from "../state-machine-model.mjs";
 import utl from "./utl.mjs";
 function fuseTransitionAttribute(pIncomingThing, pOutgoingThing, pJoinChar) {
-    return pIncomingThing
-        ? `${pIncomingThing}${pJoinChar}${pOutgoingThing}`
-        : pOutgoingThing;
+	return pIncomingThing
+		? `${pIncomingThing}${pJoinChar}${pOutgoingThing}`
+		: pOutgoingThing;
 }
 function fuseIncomingToOutgoing(pIncomingTransition, pOutgoingTransition) {
-    const lReturnValue = {
-        ...pIncomingTransition,
-        ...pOutgoingTransition,
-        from: pIncomingTransition.from,
-        to: pOutgoingTransition.to,
-    };
-    if (pOutgoingTransition.action) {
-        lReturnValue.action = fuseTransitionAttribute(pIncomingTransition.action, pOutgoingTransition.action, "\n");
-    }
-    if (lReturnValue.event || lReturnValue.cond || lReturnValue.action) {
-        lReturnValue.label = utl.formatLabel(lReturnValue.event, lReturnValue.cond, lReturnValue.action);
-    }
-    return lReturnValue;
+	const lReturnValue = {
+		...pIncomingTransition,
+		...pOutgoingTransition,
+		from: pIncomingTransition.from,
+		to: pOutgoingTransition.to,
+	};
+	if (pOutgoingTransition.action) {
+		lReturnValue.action = fuseTransitionAttribute(
+			pIncomingTransition.action,
+			pOutgoingTransition.action,
+			"\n",
+		);
+	}
+	if (lReturnValue.event || lReturnValue.cond || lReturnValue.action) {
+		lReturnValue.label = utl.formatLabel(
+			lReturnValue.event,
+			lReturnValue.cond,
+			lReturnValue.action,
+		);
+	}
+	return lReturnValue;
 }
-function fuseTransitions(pTransitions, pPseudoStateNames, pOutgoingTransitionMap) {
-    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)));
-            }
-            else {
-                pAll = pIndex === 0 ? pAll.concat(pTransition) : pAll;
-            }
-        });
-        return pAll;
-    }, []);
+function fuseTransitions(
+	pTransitions,
+	pPseudoStateNames,
+	pOutgoingTransitionMap,
+) {
+	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),
+					),
+				);
+			} else {
+				pAll = pIndex === 0 ? pAll.concat(pTransition) : pAll;
+			}
+		});
+		return pAll;
+	}, []);
 }
-function deSugarPseudoStates(pMachine, pPseudoStateNames, pOutgoingTransitionMap) {
-    const lMachine = structuredClone(pMachine);
-    if (lMachine.transitions && pPseudoStateNames.length > 0) {
-        lMachine.transitions = fuseTransitions(lMachine.transitions, pPseudoStateNames, pOutgoingTransitionMap);
-    }
-    lMachine.states = lMachine.states.map((pState) => pState.statemachine
-        ? {
-            ...pState,
-            statemachine: deSugarPseudoStates(pState.statemachine, pPseudoStateNames, pOutgoingTransitionMap),
-        }
-        : pState);
-    return lMachine;
+function deSugarPseudoStates(
+	pMachine,
+	pPseudoStateNames,
+	pOutgoingTransitionMap,
+) {
+	const lMachine = structuredClone(pMachine);
+	if (lMachine.transitions && pPseudoStateNames.length > 0) {
+		lMachine.transitions = fuseTransitions(
+			lMachine.transitions,
+			pPseudoStateNames,
+			pOutgoingTransitionMap,
+		);
+	}
+	lMachine.states = lMachine.states.map((pState) =>
+		pState.statemachine
+			? {
+					...pState,
+					statemachine: deSugarPseudoStates(
+						pState.statemachine,
+						pPseudoStateNames,
+						pOutgoingTransitionMap,
+					),
+				}
+			: pState,
+	);
+	return lMachine;
 }
 function removeStatesCascading(pMachine, pStateNames) {
-    const lMachine = structuredClone(pMachine);
-    if (lMachine.transitions) {
-        lMachine.transitions = lMachine.transitions.filter((pTransition) => !pStateNames.some((pJunctionStateName) => pJunctionStateName === pTransition.from ||
-            pJunctionStateName === pTransition.to));
-    }
-    lMachine.states = lMachine.states
-        .filter((pState) => !pStateNames.includes(pState.name))
-        .map((pState) => pState.statemachine
-        ? {
-            ...pState,
-            statemachine: removeStatesCascading(pState.statemachine, pStateNames),
-        }
-        : pState);
-    return lMachine;
+	const lMachine = structuredClone(pMachine);
+	if (lMachine.transitions) {
+		lMachine.transitions = lMachine.transitions.filter(
+			(pTransition) =>
+				!pStateNames.some(
+					(pJunctionStateName) =>
+						pJunctionStateName === pTransition.from ||
+						pJunctionStateName === pTransition.to,
+				),
+		);
+	}
+	lMachine.states = lMachine.states
+		.filter((pState) => !pStateNames.includes(pState.name))
+		.map((pState) =>
+			pState.statemachine
+				? {
+						...pState,
+						statemachine: removeStatesCascading(
+							pState.statemachine,
+							pStateNames,
+						),
+					}
+				: pState,
+		);
+	return lMachine;
 }
-export default (pMachine, pDesugarableStates = ["fork", "junction", "choice"]) => {
-    const lModel = new StateMachineModel(pMachine);
-    const lPseudoStateNames = lModel
-        .findStatesByTypes(pDesugarableStates)
-        .map(({ name }) => name);
-    const lOutgoingTransitionMap = lPseudoStateNames.reduce((pAll, pStateName) => {
-        pAll[pStateName] = lModel.findTransitionsByFrom(pStateName);
-        return pAll;
-    }, {});
-    const lMachine = deSugarPseudoStates(pMachine, lPseudoStateNames, lOutgoingTransitionMap);
-    return removeStatesCascading(lMachine, lPseudoStateNames);
+export default (
+	pMachine,
+	pDesugarableStates = ["fork", "junction", "choice"],
+) => {
+	const lModel = new StateMachineModel(pMachine);
+	const lPseudoStateNames = lModel
+		.findStatesByTypes(pDesugarableStates)
+		.map(({ name }) => name);
+	const lOutgoingTransitionMap = lPseudoStateNames.reduce(
+		(pAll, pStateName) => {
+			pAll[pStateName] = lModel.findTransitionsByFrom(pStateName);
+			return pAll;
+		},
+		{},
+	);
+	const lMachine = deSugarPseudoStates(
+		pMachine,
+		lPseudoStateNames,
+		lOutgoingTransitionMap,
+	);
+	return removeStatesCascading(lMachine, lPseudoStateNames);
 };

package/dist/transform/utl.mjs

@@ -1,16 +1,16 @@
 function formatLabel(pEvent, pCond, pActions) {
-    let lReturnValue = "";
-    if (pEvent) {
-        lReturnValue += pEvent;
-    }
-    if (pCond) {
-        lReturnValue += ` [${pCond}]`;
-    }
-    if (pActions) {
-        lReturnValue += `/ ${pActions}`;
-    }
-    return lReturnValue.trim();
+	let lReturnValue = "";
+	if (pEvent) {
+		lReturnValue += pEvent;
+	}
+	if (pCond) {
+		lReturnValue += ` [${pCond}]`;
+	}
+	if (pActions) {
+		lReturnValue += `/ ${pActions}`;
+	}
+	return lReturnValue.trim();
 }
 export default {
-    formatLabel,
+	formatLabel,
 };

package/dist/version.mjs

@@ -1 +1 @@
-export const version = "12.0.5";
+export const version = "12.0.7";

package/package.json

@@ -1,76 +1,76 @@
 {
-  "name": "state-machine-cat",
-  "version": "12.0.5",
-  "description": "write beautiful state charts",
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
-  "exports": {
-    ".": [
-      {
-        "types": "./types/state-machine-cat.d.mts",
-        "import": "./dist/index.mjs"
-      }
-    ]
-  },
-  "types": "types/state-machine-cat.d.mts",
-  "imports": {
-    "#*": "./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"
-  ],
-  "files": [
-    "bin/",
-    "dist/",
-    "types/",
-    "package.json",
-    "README.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "state",
-    "state chart",
-    "state diagram",
-    "state machine",
-    "finite state machine",
-    "fsm",
-    "uml",
-    "scxml"
-  ],
-  "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"
-  },
-  "dependencies": {
-    "@hpcc-js/wasm": "2.15.3",
-    "ajv": "8.12.0",
-    "commander": "12.0.0",
-    "fast-xml-parser": "4.3.4",
-    "handlebars": "4.7.8",
-    "he": "1.2.0",
-    "semver": "^7.5.4",
-    "traverse": "0.6.8"
-  },
-  "engines": {
-    "node": "^18.17||>=20"
-  },
-  "homepage": "https://state-machine-cat.js.org",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sverweij/state-machine-cat.git"
-  },
-  "bugs": {
-    "url": "https://github.com/sverweij/state-machine-cat/issues"
-  },
-  "scripts": {
-    "test": "echo for test, build and static analysis scripts: see the github repository"
-  }
+	"name": "state-machine-cat",
+	"version": "12.0.7",
+	"description": "write beautiful state charts",
+	"main": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
+	"exports": {
+		".": [
+			{
+				"types": "./types/state-machine-cat.d.mts",
+				"import": "./dist/index.mjs"
+			}
+		]
+	},
+	"types": "types/state-machine-cat.d.mts",
+	"imports": {
+		"#*": "./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"
+	],
+	"files": [
+		"bin/",
+		"dist/",
+		"types/",
+		"package.json",
+		"README.md",
+		"LICENSE"
+	],
+	"keywords": [
+		"state",
+		"state chart",
+		"state diagram",
+		"state machine",
+		"finite state machine",
+		"fsm",
+		"uml",
+		"scxml"
+	],
+	"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"
+	},
+	"dependencies": {
+		"@hpcc-js/wasm": "2.16.1",
+		"ajv": "8.12.0",
+		"commander": "12.0.0",
+		"fast-xml-parser": "4.3.6",
+		"handlebars": "4.7.8",
+		"he": "1.2.0",
+		"semver": "^7.6.0",
+		"traverse": "0.6.9"
+	},
+	"engines": {
+		"node": "^18.17||>=20"
+	},
+	"homepage": "https://state-machine-cat.js.org",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/sverweij/state-machine-cat.git"
+	},
+	"bugs": {
+		"url": "https://github.com/sverweij/state-machine-cat/issues"
+	},
+	"scripts": {
+		"test": "echo for test, build and static analysis scripts: see the github repository"
+	}
 }