state-machine-cat 13.0.2 → 13.0.3

package/dist/parse/index.mjs

@@ -4,13 +4,7 @@ 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();
-function validateAgainstSchema(pSchema, pObject) {
-	if (!ajv.validate(pSchema, pObject)) {
-		throw new Error(
-			`The provided JSON is not a valid state-machine-cat AST: ${ajv.errorsText()}.\n`,
-		);
-	}
-}
+const validate = ajv.compile($schema);
 export default {
 	getAST(pScript, pOptions) {
 		let lReturnValue = pScript;
@@ -21,7 +15,11 @@ export default {
 		} else if (typeof pScript === "string") {
 			lReturnValue = JSON.parse(pScript);
 		}
-		validateAgainstSchema($schema, lReturnValue);
+		if (!validate(lReturnValue)) {
+			throw new Error(
+				`The provided JSON is not a valid state-machine-cat AST: ${ajv.errorsText()}.\n`,
+			);
+		}
 		return lReturnValue;
 	},
 };

package/dist/parse/parser-helpers.mjs

@@ -64,22 +64,22 @@ function extractUndeclaredStates(pStateMachine, pKnownStateNames) {
 		pKnownStateNames ?? getAlreadyDeclaredStates(pStateMachine);
 	pStateMachine.states = pStateMachine?.states ?? [];
 	const lTransitions = pStateMachine?.transitions ?? [];
-	pStateMachine.states.filter(isComposite).forEach((pState) => {
-		pState.statemachine.states = extractUndeclaredStates(
-			pState.statemachine,
+	for (const lState of pStateMachine.states.filter(isComposite)) {
+		lState.statemachine.states = extractUndeclaredStates(
+			lState.statemachine,
 			pKnownStateNames,
 		);
-	});
-	lTransitions.forEach((pTransition) => {
-		if (!stateExists(pKnownStateNames, pTransition.from)) {
-			pKnownStateNames.push(pTransition.from);
-			pStateMachine.states.push(initState(pTransition.from));
+	}
+	for (const lTransition of lTransitions) {
+		if (!stateExists(pKnownStateNames, lTransition.from)) {
+			pKnownStateNames.push(lTransition.from);
+			pStateMachine.states.push(initState(lTransition.from));
 		}
-		if (!stateExists(pKnownStateNames, pTransition.to)) {
-			pKnownStateNames.push(pTransition.to);
-			pStateMachine.states.push(initState(pTransition.to));
+		if (!stateExists(pKnownStateNames, lTransition.to)) {
+			pKnownStateNames.push(lTransition.to);
+			pStateMachine.states.push(initState(lTransition.to));
 		}
-	});
+	}
 	return pStateMachine.states;
 }
 function classifyForkJoin(pInComingCount, pOutGoingCount) {

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

@@ -345,13 +345,13 @@ function peg$parse(input, options) {
 	}
 	function peg$f8(notes, id, extended_state_attributes, actions, statemachine) {
 		let lState = parserHelpers.initState(id);
-		(extended_state_attributes || []).forEach((pExtendedAttribute) =>
+		for (const lExtendedAttribute of extended_state_attributes || []) {
 			parserHelpers.setIf(
 				lState,
-				pExtendedAttribute.name,
-				pExtendedAttribute.value,
-			),
-		);
+				lExtendedAttribute.name,
+				lExtendedAttribute.value,
+			);
+		}
 		parserHelpers.setIf(
 			lState,
 			"typeExplicitlySet",
@@ -408,13 +408,13 @@ function peg$parse(input, options) {
 				parserHelpers.parseTransitionExpression(label),
 			);
 		}
-		(extended_attributes || []).forEach((pExtendedAttribute) =>
+		for (const lExtendedAttribute of extended_attributes || []) {
 			parserHelpers.setIf(
 				trans,
-				pExtendedAttribute.name,
-				pExtendedAttribute.value,
-			),
-		);
+				lExtendedAttribute.name,
+				lExtendedAttribute.value,
+			);
+		}
 		parserHelpers.setIfNotEmpty(trans, "note", notes);
 		trans.id = options.counter.next();
 		return trans;

package/dist/render/dot/attributebuilder.mjs

@@ -37,11 +37,20 @@ function toNameValueString(pAttribute) {
 	return `${pAttribute.name}=${pAttribute.value}`;
 }
 export function buildGraphAttributes(pEngine, pDirection, pDotGraphAttributes) {
-	return GENERIC_GRAPH_ATTRIBUTES.concat(GRAPH_ATTRIBUTES[pEngine] || [])
-		.concat(DIRECTION_ATTRIBUTES[pDirection] || [])
-		.concat(pDotGraphAttributes || [])
-		.map(toNameValueString)
-		.join(" ");
+	const lParts = [];
+	for (const lAttribute of GENERIC_GRAPH_ATTRIBUTES) {
+		lParts.push(lAttribute);
+	}
+	for (const lAttribute of GRAPH_ATTRIBUTES[pEngine] || []) {
+		lParts.push(lAttribute);
+	}
+	for (const lAttribute of DIRECTION_ATTRIBUTES[pDirection] || []) {
+		lParts.push(lAttribute);
+	}
+	for (const lAttribute of pDotGraphAttributes || []) {
+		lParts.push(lAttribute);
+	}
+	return lParts.map(toNameValueString).join(" ");
 }
 export function buildNodeAttributes(pDotNodeAttributes) {
 	return NODE_ATTRIBUTES.concat(pDotNodeAttributes || [])

package/dist/render/dot/index.mjs

@@ -180,9 +180,9 @@ function state(pState, pIndent, pOptions, pModel, pRenderedTransitions) {
 		pState.name,
 		pRenderedTransitions,
 	);
-	lCandidateTransitions.forEach((pTransition) => {
-		pRenderedTransitions.add(pTransition.id);
-	});
+	for (const lTransition of lCandidateTransitions) {
+		pRenderedTransitions.add(lTransition.id);
+	}
 	const lTransitions = transitions(
 		lCandidateTransitions,
 		pIndent,

package/dist/state-machine-model.mjs

@@ -1,19 +1,17 @@
 function flattenStatesToMap(pStates, pMap, pParent = "") {
-	pStates
-		.filter((pState) => Boolean(pState.statemachine))
-		.forEach((pState) => {
-			if (Object.hasOwn(pState.statemachine, "states")) {
-				flattenStatesToMap(pState.statemachine.states, pMap, pState.name);
-			}
-		});
-	pStates.forEach((pState) =>
-		pMap.set(pState.name, {
-			name: pState.name,
-			type: pState.type,
-			statemachine: Boolean(pState.statemachine),
+	for (const lState of pStates) {
+		if (lState?.statemachine?.states) {
+			flattenStatesToMap(lState.statemachine.states, pMap, lState.name);
+		}
+	}
+	for (const lState of pStates) {
+		pMap.set(lState.name, {
+			name: lState.name,
+			type: lState.type,
+			statemachine: Boolean(lState.statemachine),
 			parent: pParent,
-		}),
-	);
+		});
+	}
 }
 function flattenTransitions(pStateMachine) {
 	let lTransitions = [];
@@ -21,13 +19,13 @@ function flattenTransitions(pStateMachine) {
 		lTransitions = structuredClone(pStateMachine.transitions);
 	}
 	if (Object.hasOwn(pStateMachine, "states")) {
-		pStateMachine.states
-			.filter((pState) => Boolean(pState.statemachine))
-			.forEach((pState) => {
+		for (const lState of pStateMachine.states) {
+			if (lState.statemachine) {
 				lTransitions = lTransitions.concat(
-					flattenTransitions(pState.statemachine),
+					flattenTransitions(lState.statemachine),
 				);
-			});
+			}
+		}
 	}
 	return lTransitions;
 }

package/dist/transform/desugar.mjs

@@ -40,20 +40,24 @@ function fuseTransitions(
 	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, pCounter),
-					),
-				);
-			} else {
-				pAll = pIndex === 0 ? pAll.concat(pTransition) : pAll;
+	const lResult = [];
+	for (const lTransition of pTransitions) {
+		let lAdded = false;
+		for (const lStateName of pPseudoStateNames) {
+			if (lStateName === lTransition.to && pOutgoingTransitionMap[lStateName]) {
+				for (const lOutgoing of pOutgoingTransitionMap[lStateName]) {
+					lResult.push(
+						fuseIncomingToOutgoing(lTransition, lOutgoing, pCounter),
+					);
+				}
+				lAdded = true;
 			}
-		});
-		return pAll;
-	}, []);
+		}
+		if (!lAdded) {
+			lResult.push(lTransition);
+		}
+	}
+	return lResult;
 }
 function deSugarPseudoStates(
 	pMachine,

package/dist/version.mjs

@@ -1 +1 @@
-export const version = "13.0.2";
+export const version = "13.0.3";

package/package.json

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