state-machine-cat 12.0.5 → 12.0.7

package/dist/render/dot/state-transformers.mjs

@@ -1,112 +1,123 @@
 import utl from "./utl.mjs";
 function isType(pString) {
-    return (pState) => pState.type === pString;
+	return (pState) => pState.type === pString;
 }
 function isOneOfTypes(pStringArray) {
-    return (pState) => pStringArray.includes(pState.type);
+	return (pState) => pStringArray.includes(pState.type);
 }
 function setLabel(pState) {
-    const lState = structuredClone(pState);
-    lState.label = pState.label || pState.name;
-    return lState;
+	const lState = structuredClone(pState);
+	lState.label = pState.label || pState.name;
+	return lState;
 }
 function nameNote(pState) {
-    if (pState.note) {
-        return {
-            noteName: `note_${pState.name}`,
-            ...pState,
-        };
-    }
-    return pState;
+	if (pState.note) {
+		return {
+			noteName: `note_${pState.name}`,
+			...pState,
+		};
+	}
+	return pState;
 }
 function classifyState(pState) {
-    const lState = { ...pState };
-    const lClasses = ["state", pState.type];
-    if (pState.class) {
-        lClasses.push(pState.class.trim().replace(/[ ]{2,}/g, " "));
-    }
-    lState.class = lClasses.join(" ");
-    return lState;
+	const lState = { ...pState };
+	const lClasses = ["state", pState.type];
+	if (pState.class) {
+		lClasses.push(pState.class.trim().replace(/[ ]{2,}/g, " "));
+	}
+	lState.class = lClasses.join(" ");
+	return lState;
 }
 function formatActionType(pString) {
-    return pString === "activity" ? "" : `${pString}/ `;
+	return pString === "activity" ? "" : `${pString}/ `;
 }
 function flattenActions(pState) {
-    if (pState.actions) {
-        return {
-            ...pState,
-            actionStrings: pState.actions.map((pAction) => `${formatActionType(pAction.type)}${pAction.body}`),
-        };
-    }
-    return pState;
+	if (pState.actions) {
+		return {
+			...pState,
+			actionStrings: pState.actions.map(
+				(pAction) => `${formatActionType(pAction.type)}${pAction.body}`,
+			),
+		};
+	}
+	return pState;
 }
 function flattenNote(pState) {
-    if (pState.note) {
-        return {
-            ...pState,
-            noteFlattened: pState.note.join(""),
-        };
-    }
-    return pState;
+	if (pState.note) {
+		return {
+			...pState,
+			noteFlattened: pState.note.join(""),
+		};
+	}
+	return pState;
 }
 function recolor(pNodeAttributes) {
-    return (pState) => {
-        const lNodeColor = (pNodeAttributes || []).find((pAttribute) => pAttribute.name === "color")?.value;
-        if (lNodeColor &&
-            !pState.color &&
-            isOneOfTypes([
-                "initial",
-                "fork",
-                "join",
-                "junction",
-                "forkjoin",
-                "final",
-            ])(pState)) {
-            pState.color = lNodeColor;
-        }
-        return pState;
-    };
+	return (pState) => {
+		const lNodeColor = (pNodeAttributes || []).find(
+			(pAttribute) => pAttribute.name === "color",
+		)?.value;
+		if (
+			lNodeColor &&
+			!pState.color &&
+			isOneOfTypes([
+				"initial",
+				"fork",
+				"join",
+				"junction",
+				"forkjoin",
+				"final",
+			])(pState)
+		) {
+			pState.color = lNodeColor;
+		}
+		return pState;
+	};
 }
 function escapeStateStrings(pState) {
-    if (pState.note) {
-        return {
-            ...pState,
-            note: pState.note.map(utl.escapeString),
-        };
-    }
-    return pState;
+	if (pState.note) {
+		return {
+			...pState,
+			note: pState.note.map(utl.escapeString),
+		};
+	}
+	return pState;
 }
 function tipForkJoinStates(pDirection) {
-    return (pState) => {
-        if (isOneOfTypes(["fork", "join", "forkjoin"])(pState)) {
-            return {
-                sizingExtras: utl.isVertical(pDirection) ? "height=0.1" : "width=0.1",
-                ...pState,
-            };
-        }
-        return pState;
-    };
+	return (pState) => {
+		if (isOneOfTypes(["fork", "join", "forkjoin"])(pState)) {
+			return {
+				sizingExtras: utl.isVertical(pDirection) ? "height=0.1" : "width=0.1",
+				...pState,
+			};
+		}
+		return pState;
+	};
 }
 function flagParallelChildren(pState) {
-    if (pState.type === "parallel" &&
-        pState.statemachine &&
-        pState.statemachine.states) {
-        pState.statemachine.states = pState.statemachine.states.map((pChildState) => isType("regular")(pChildState)
-            ? { ...pChildState, parentIsParallel: true }
-            : pChildState);
-    }
-    return pState;
+	if (
+		pState.type === "parallel" &&
+		pState.statemachine &&
+		pState.statemachine.states
+	) {
+		pState.statemachine.states = pState.statemachine.states.map(
+			(pChildState) =>
+				isType("regular")(pChildState)
+					? { ...pChildState, parentIsParallel: true }
+					: pChildState,
+		);
+	}
+	return pState;
 }
 export default {
-    isType,
-    isOneOfTypes,
-    setLabel,
-    classifyState,
-    nameNote,
-    flattenActions,
-    flattenNote,
-    recolor,
-    escapeStateStrings,
-    tipForkJoinStates,
-    flagParallelChildren,
+	isType,
+	isOneOfTypes,
+	setLabel,
+	classifyState,
+	nameNote,
+	flattenActions,
+	flattenNote,
+	recolor,
+	escapeStateStrings,
+	tipForkJoinStates,
+	flagParallelChildren,
 };

package/dist/render/dot/transition-transformers.mjs

@@ -1,49 +1,47 @@
 import utl from "./utl.mjs";
 function escapeTransitionStrings(pTransition) {
-    const lTransition = { ...pTransition };
-    if (lTransition.note) {
-        lTransition.note = lTransition.note.map(utl.escapeString);
-    }
-    if (lTransition.label) {
-        lTransition.label = utl.escapeLabelString(lTransition.label);
-    }
-    return lTransition;
+	const lTransition = { ...pTransition };
+	if (lTransition.note) {
+		lTransition.note = lTransition.note.map(utl.escapeString);
+	}
+	if (lTransition.label) {
+		lTransition.label = utl.escapeLabelString(lTransition.label);
+	}
+	return lTransition;
 }
 function addPorts(pDirection) {
-    return (pTransition) => {
-        let lAdditionalAttributes = {};
-        if (pTransition.isCompositeSelf) {
-            if (utl.isVertical(pDirection)) {
-                lAdditionalAttributes = {
-                    tailportflags: `tailport="e" headport="e"`,
-                    headportflags: `tailport="w"`,
-                };
-            }
-            else if (pTransition.hasParent) {
-                lAdditionalAttributes = {
-                    tailportflags: `tailport="n" headport="n"`,
-                    headportflags: `tailport="s"`,
-                };
-            }
-            else {
-                lAdditionalAttributes = {
-                    tailportflags: `tailport="s" headport="s"`,
-                    headportflags: `tailport="n"`,
-                };
-            }
-        }
-        return { ...pTransition, ...lAdditionalAttributes };
-    };
+	return (pTransition) => {
+		let lAdditionalAttributes = {};
+		if (pTransition.isCompositeSelf) {
+			if (utl.isVertical(pDirection)) {
+				lAdditionalAttributes = {
+					tailportflags: `tailport="e" headport="e"`,
+					headportflags: `tailport="w"`,
+				};
+			} else if (pTransition.hasParent) {
+				lAdditionalAttributes = {
+					tailportflags: `tailport="n" headport="n"`,
+					headportflags: `tailport="s"`,
+				};
+			} else {
+				lAdditionalAttributes = {
+					tailportflags: `tailport="s" headport="s"`,
+					headportflags: `tailport="n"`,
+				};
+			}
+		}
+		return { ...pTransition, ...lAdditionalAttributes };
+	};
 }
 function classifyTransition(pTransition) {
-    const lClasses = ["transition"];
-    if (pTransition.type) {
-        lClasses.push(pTransition.type);
-    }
-    if (pTransition.class) {
-        lClasses.push(pTransition.class.trim().replace(/[ ]{2,}/g, " "));
-    }
-    pTransition.class = lClasses.join(" ");
-    return pTransition;
+	const lClasses = ["transition"];
+	if (pTransition.type) {
+		lClasses.push(pTransition.type);
+	}
+	if (pTransition.class) {
+		lClasses.push(pTransition.class.trim().replace(/[ ]{2,}/g, " "));
+	}
+	pTransition.class = lClasses.join(" ");
+	return pTransition;
 }
 export default { escapeTransitionStrings, addPorts, classifyTransition };

package/dist/render/dot/utl.mjs

@@ -1,29 +1,31 @@
 function escapeString(pString) {
-    return pString
-        .replace(/\\/g, "\\\\")
-        .replace(/\n\s*/g, "\\l")
-        .replace(/"/g, '\\"')
-        .concat("\\l");
+	return pString
+		.replace(/\\/g, "\\\\")
+		.replace(/\n\s*/g, "\\l")
+		.replace(/"/g, '\\"')
+		.concat("\\l");
 }
 function escapeLabelString(pString) {
-    return pString
-        .replace(/\\/g, "\\\\")
-        .replace(/\n\s*/g, "   \\l")
-        .replace(/"/g, '\\"')
-        .concat("   \\l");
+	return pString
+		.replace(/\\/g, "\\\\")
+		.replace(/\n\s*/g, "   \\l")
+		.replace(/"/g, '\\"')
+		.concat("   \\l");
 }
 function isVertical(pDirection) {
-    const lDirection = pDirection || "top-down";
-    return lDirection === "top-down" || lDirection === "bottom-top";
+	const lDirection = pDirection || "top-down";
+	return lDirection === "top-down" || lDirection === "bottom-top";
 }
 function isCompositeSelf(pStateMachineModel, pTransition) {
-    return (pTransition.from === pTransition.to &&
-        pStateMachineModel.findStateByName(pTransition.from).statemachine &&
-        !(pTransition.type === "internal"));
+	return (
+		pTransition.from === pTransition.to &&
+		pStateMachineModel.findStateByName(pTransition.from).statemachine &&
+		!(pTransition.type === "internal")
+	);
 }
 export default {
-    escapeString,
-    escapeLabelString,
-    isVertical,
-    isCompositeSelf,
+	escapeString,
+	escapeLabelString,
+	isVertical,
+	isCompositeSelf,
 };

package/dist/render/index-node.mjs

@@ -6,20 +6,20 @@ import scjson from "./scjson/index.mjs";
 import scxml from "./scxml/index.mjs";
 const smcat = smcatRendererAsImported;
 export default function getRenderFunction(pOutputType) {
-    const lOutputType2RenderFunctionMap = new Map([
-        ["smcat", smcat],
-        ["dot", renderDot],
-        ["svg", vector],
-        ["eps", vector],
-        ["ps", vector],
-        ["ps2", vector],
-        ["oldsvg", oldVector],
-        ["oldps2", oldVector],
-        ["oldeps", oldVector],
-        ["pdf", vector],
-        ["png", vector],
-        ["scjson", scjson],
-        ["scxml", scxml],
-    ]);
-    return lOutputType2RenderFunctionMap.get(pOutputType) ?? ((pX) => pX);
+	const lOutputType2RenderFunctionMap = new Map([
+		["smcat", smcat],
+		["dot", renderDot],
+		["svg", vector],
+		["eps", vector],
+		["ps", vector],
+		["ps2", vector],
+		["oldsvg", oldVector],
+		["oldps2", oldVector],
+		["oldeps", oldVector],
+		["pdf", vector],
+		["png", vector],
+		["scjson", scjson],
+		["scxml", scxml],
+	]);
+	return lOutputType2RenderFunctionMap.get(pOutputType) ?? ((pX) => pX);
 }

package/dist/render/index.mjs

@@ -5,13 +5,13 @@ import scjson from "./scjson/index.mjs";
 import scxml from "./scxml/index.mjs";
 const smcat = smcatRendererAsImported;
 export default function getRenderFunction(pOutputType) {
-    const lOutputType2RenderFunctionMap = new Map([
-        ["smcat", smcat],
-        ["dot", renderDot],
-        ["svg", svg],
-        ["oldsvg", svg],
-        ["scjson", scjson],
-        ["scxml", scxml],
-    ]);
-    return lOutputType2RenderFunctionMap.get(pOutputType) ?? ((pX) => pX);
+	const lOutputType2RenderFunctionMap = new Map([
+		["smcat", smcat],
+		["dot", renderDot],
+		["svg", svg],
+		["oldsvg", svg],
+		["scjson", scjson],
+		["scxml", scxml],
+	]);
+	return lOutputType2RenderFunctionMap.get(pOutputType) ?? ((pX) => pX);
 }

package/dist/render/scjson/index.mjs

@@ -2,120 +2,137 @@ import StateMachineModel from "../../state-machine-model.mjs";
 import makeValidXMLName from "./make-valid-xml-name.mjs";
 import makeValidEventNames from "./make-valid-event-names.mjs";
 const STATE_TYPE2SCXML_STATE_KIND = {
-    regular: "state",
-    initial: "initial",
-    final: "final",
-    terminate: "final",
-    parallel: "parallel",
-    history: "history",
-    deephistory: "history",
+	regular: "state",
+	initial: "initial",
+	final: "final",
+	terminate: "final",
+	parallel: "parallel",
+	history: "history",
+	deephistory: "history",
 };
 function stateType2SCXMLStateKind(pStateType) {
-    return STATE_TYPE2SCXML_STATE_KIND[pStateType] || "state";
+	return STATE_TYPE2SCXML_STATE_KIND[pStateType] || "state";
 }
 function transformTransition(pTransition) {
-    const lReturnValue = {
-        target: makeValidXMLName(pTransition.to),
-    };
-    if (pTransition.event) {
-        lReturnValue.event = makeValidEventNames(pTransition.event);
-    }
-    if (pTransition.cond) {
-        lReturnValue.cond = pTransition.cond;
-    }
-    if (pTransition.action) {
-        lReturnValue.action = pTransition.action;
-    }
-    if (pTransition.type) {
-        lReturnValue.type = pTransition.type;
-    }
-    return lReturnValue;
+	const lReturnValue = {
+		target: makeValidXMLName(pTransition.to),
+	};
+	if (pTransition.event) {
+		lReturnValue.event = makeValidEventNames(pTransition.event);
+	}
+	if (pTransition.cond) {
+		lReturnValue.cond = pTransition.cond;
+	}
+	if (pTransition.action) {
+		lReturnValue.action = pTransition.action;
+	}
+	if (pTransition.type) {
+		lReturnValue.type = pTransition.type;
+	}
+	return lReturnValue;
 }
 function extractTriggers(pTriggers, pTriggerType) {
-    return pTriggers
-        .filter((pTrigger) => pTrigger.type === pTriggerType)
-        .map((pTrigger) => pTrigger.body);
+	return pTriggers
+		.filter((pTrigger) => pTrigger.type === pTriggerType)
+		.map((pTrigger) => pTrigger.body);
 }
 function pullOutActionType(pReturnValue, pTriggersType, pActions, pActionType) {
-    const lTriggerArray = extractTriggers(pActions, pActionType);
-    if (lTriggerArray.length > 0) {
-        pReturnValue[pTriggersType] = (pReturnValue[pTriggersType] || []).concat(lTriggerArray);
-    }
+	const lTriggerArray = extractTriggers(pActions, pActionType);
+	if (lTriggerArray.length > 0) {
+		pReturnValue[pTriggersType] = (pReturnValue[pTriggersType] || []).concat(
+			lTriggerArray,
+		);
+	}
 }
 function transformTriggers(pReturnValue, pState) {
-    if (pState.actions) {
-        pullOutActionType(pReturnValue, "onentries", pState.actions, "entry");
-        pullOutActionType(pReturnValue, "onentries", pState.actions, "activity");
-        pullOutActionType(pReturnValue, "onexits", pState.actions, "exit");
-    }
+	if (pState.actions) {
+		pullOutActionType(pReturnValue, "onentries", pState.actions, "entry");
+		pullOutActionType(pReturnValue, "onentries", pState.actions, "activity");
+		pullOutActionType(pReturnValue, "onexits", pState.actions, "exit");
+	}
 }
 function transformTransitions(pReturnValue, pState, pTransitions) {
-    const lTransitions = pTransitions
-        .filter((pTransition) => pTransition.from === pState.name)
-        .map(transformTransition);
-    if (lTransitions.length > 0) {
-        pReturnValue.transitions = lTransitions;
-    }
+	const lTransitions = pTransitions
+		.filter((pTransition) => pTransition.from === pState.name)
+		.map(transformTransition);
+	if (lTransitions.length > 0) {
+		pReturnValue.transitions = lTransitions;
+	}
 }
 function transformCompositeState(pReturnValue, pState, pTransitions) {
-    if (pState.statemachine) {
-        const lRenderedState = render(pState.statemachine, undefined, pTransitions);
-        pReturnValue.states = (pReturnValue.states || []).concat(lRenderedState.states);
-        if (lRenderedState.initial) {
-            pReturnValue.initial = lRenderedState.initial;
-        }
-    }
+	if (pState.statemachine) {
+		const lRenderedState = render(pState.statemachine, undefined, pTransitions);
+		pReturnValue.states = (pReturnValue.states || []).concat(
+			lRenderedState.states,
+		);
+		if (lRenderedState.initial) {
+			pReturnValue.initial = lRenderedState.initial;
+		}
+	}
 }
 function transformState(pTransitions) {
-    pTransitions = pTransitions || [];
-    return (pState) => {
-        const lReturnValue = {
-            kind: stateType2SCXMLStateKind(pState.type),
-            id: makeValidXMLName(pState.name),
-        };
-        if (pState.type === "deephistory") {
-            lReturnValue.type = "deep";
-        }
-        transformTriggers(lReturnValue, pState);
-        transformTransitions(lReturnValue, pState, pTransitions);
-        transformCompositeState(lReturnValue, pState, pTransitions);
-        return lReturnValue;
-    };
+	pTransitions = pTransitions || [];
+	return (pState) => {
+		const lReturnValue = {
+			kind: stateType2SCXMLStateKind(pState.type),
+			id: makeValidXMLName(pState.name),
+		};
+		if (pState.type === "deephistory") {
+			lReturnValue.type = "deep";
+		}
+		transformTriggers(lReturnValue, pState);
+		transformTransitions(lReturnValue, pState, pTransitions);
+		transformCompositeState(lReturnValue, pState, pTransitions);
+		return lReturnValue;
+	};
 }
 function findInitialPseudoStateName(pStateMachine) {
-    const lInitial = pStateMachine.states.filter((pState) => pState.type === "initial");
-    if (lInitial.length > 0) {
-        return lInitial[0].name;
-    }
-    return undefined;
+	const lInitial = pStateMachine.states.filter(
+		(pState) => pState.type === "initial",
+	);
+	if (lInitial.length > 0) {
+		return lInitial[0].name;
+	}
+	return undefined;
 }
 function findInitialStateName(pStateMachine, pInitialPseudoStateName) {
-    let lReturnValue = pInitialPseudoStateName;
-    if (pInitialPseudoStateName && pStateMachine.transitions) {
-        const lInitialTransitions = pStateMachine.transitions.filter((pTransition) => pTransition.from === pInitialPseudoStateName);
-        if (lInitialTransitions.length > 0 && !lInitialTransitions[0].action) {
-            lReturnValue = lInitialTransitions[0].to;
-        }
-    }
-    return lReturnValue;
+	let lReturnValue = pInitialPseudoStateName;
+	if (pInitialPseudoStateName && pStateMachine.transitions) {
+		const lInitialTransitions = pStateMachine.transitions.filter(
+			(pTransition) => pTransition.from === pInitialPseudoStateName,
+		);
+		if (lInitialTransitions.length > 0 && !lInitialTransitions[0].action) {
+			lReturnValue = lInitialTransitions[0].to;
+		}
+	}
+	return lReturnValue;
 }
 export default function render(pStateMachine, _pOptions, pTransitions) {
-    const lInitialPseudoStateName = findInitialPseudoStateName(pStateMachine);
-    const lInitialStateName = findInitialStateName(pStateMachine, lInitialPseudoStateName);
-    const lReturnValue = {
-        states: pStateMachine.states
-            .filter((pState) => {
-            if (lInitialStateName &&
-                lInitialStateName !== lInitialPseudoStateName) {
-                return pState.type !== "initial";
-            }
-            return true;
-        })
-            .map(transformState(pTransitions ||
-            new StateMachineModel(pStateMachine).flattenedTransitions)),
-    };
-    if (lInitialStateName) {
-        lReturnValue.initial = makeValidXMLName(lInitialStateName);
-    }
-    return lReturnValue;
+	const lInitialPseudoStateName = findInitialPseudoStateName(pStateMachine);
+	const lInitialStateName = findInitialStateName(
+		pStateMachine,
+		lInitialPseudoStateName,
+	);
+	const lReturnValue = {
+		states: pStateMachine.states
+			.filter((pState) => {
+				if (
+					lInitialStateName &&
+					lInitialStateName !== lInitialPseudoStateName
+				) {
+					return pState.type !== "initial";
+				}
+				return true;
+			})
+			.map(
+				transformState(
+					pTransitions ||
+						new StateMachineModel(pStateMachine).flattenedTransitions,
+				),
+			),
+	};
+	if (lInitialStateName) {
+		lReturnValue.initial = makeValidXMLName(lInitialStateName);
+	}
+	return lReturnValue;
 }