state-machine-cat 12.0.6 → 12.0.7

package/dist/options.mjs

@@ -1,61 +1,61 @@
 const ALLOWED_VALUES = Object.freeze({
-    inputType: {
-        default: "smcat",
-        values: [{ name: "smcat" }, { name: "json" }, { name: "scxml" }],
-    },
-    outputType: {
-        default: "svg",
-        values: [
-            { name: "ast" },
-            { name: "dot" },
-            { name: "eps" },
-            { name: "json" },
-            { name: "oldeps" },
-            { name: "oldps" },
-            { name: "oldps2" },
-            { name: "oldsvg" },
-            { name: "pdf" },
-            { name: "png" },
-            { name: "ps" },
-            { name: "ps2" },
-            { name: "scjson" },
-            { name: "scxml" },
-            { name: "smcat" },
-            { name: "svg" },
-        ],
-    },
-    engine: {
-        default: "dot",
-        values: [
-            { name: "dot" },
-            { name: "circo" },
-            { name: "fdp" },
-            { name: "neato" },
-            { name: "osage" },
-            { name: "twopi" },
-        ],
-    },
-    direction: {
-        default: "top-down",
-        values: [
-            { name: "top-down" },
-            { name: "bottom-top" },
-            { name: "left-right" },
-            { name: "right-left" },
-        ],
-    },
-    desugar: {
-        default: false,
-        values: [{ name: true }, { name: false }],
-    },
+	inputType: {
+		default: "smcat",
+		values: [{ name: "smcat" }, { name: "json" }, { name: "scxml" }],
+	},
+	outputType: {
+		default: "svg",
+		values: [
+			{ name: "ast" },
+			{ name: "dot" },
+			{ name: "eps" },
+			{ name: "json" },
+			{ name: "oldeps" },
+			{ name: "oldps" },
+			{ name: "oldps2" },
+			{ name: "oldsvg" },
+			{ name: "pdf" },
+			{ name: "png" },
+			{ name: "ps" },
+			{ name: "ps2" },
+			{ name: "scjson" },
+			{ name: "scxml" },
+			{ name: "smcat" },
+			{ name: "svg" },
+		],
+	},
+	engine: {
+		default: "dot",
+		values: [
+			{ name: "dot" },
+			{ name: "circo" },
+			{ name: "fdp" },
+			{ name: "neato" },
+			{ name: "osage" },
+			{ name: "twopi" },
+		],
+	},
+	direction: {
+		default: "top-down",
+		values: [
+			{ name: "top-down" },
+			{ name: "bottom-top" },
+			{ name: "left-right" },
+			{ name: "right-left" },
+		],
+	},
+	desugar: {
+		default: false,
+		values: [{ name: true }, { name: false }],
+	},
 });
 function getOptionValue(pOptions, pOptionName) {
-    return pOptions?.[pOptionName] ?? ALLOWED_VALUES[pOptionName].default;
+	return pOptions?.[pOptionName] ?? ALLOWED_VALUES[pOptionName].default;
 }
 function getAllowedValues() {
-    return ALLOWED_VALUES;
+	return ALLOWED_VALUES;
 }
 export default {
-    getAllowedValues,
-    getOptionValue,
+	getAllowedValues,
+	getOptionValue,
 };

package/dist/parse/index.mjs

@@ -5,23 +5,23 @@ 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`);
-    }
+	if (!ajv.validate(pSchema, pObject)) {
+		throw new Error(
+			`The provided JSON is not a valid state-machine-cat AST: ${ajv.errorsText()}.\n`,
+		);
+	}
 }
 export default {
-    getAST(pScript, pOptions) {
-        let lReturnValue = pScript;
-        if (options.getOptionValue(pOptions, "inputType") === "smcat") {
-            lReturnValue = parseSmCat(pScript);
-        }
-        else if (options.getOptionValue(pOptions, "inputType") === "scxml") {
-            lReturnValue = parseSCXML(pScript);
-        }
-        else if (typeof pScript === "string") {
-            lReturnValue = JSON.parse(pScript);
-        }
-        validateAgainstSchema($schema, lReturnValue);
-        return lReturnValue;
-    },
+	getAST(pScript, pOptions) {
+		let lReturnValue = pScript;
+		if (options.getOptionValue(pOptions, "inputType") === "smcat") {
+			lReturnValue = parseSmCat(pScript);
+		} else if (options.getOptionValue(pOptions, "inputType") === "scxml") {
+			lReturnValue = parseSCXML(pScript);
+		} else if (typeof pScript === "string") {
+			lReturnValue = JSON.parse(pScript);
+		}
+		validateAgainstSchema($schema, lReturnValue);
+		return lReturnValue;
+	},
 };

package/dist/parse/parser-helpers.mjs

@@ -1,175 +1,195 @@
 import StateMachineModel from "../state-machine-model.mjs";
-const TRIGGER_RE_AS_A_STRING = "^(entry|activity|exit)\\s*/\\s*([^\\n$]*)(\\n|$)";
+const TRIGGER_RE_AS_A_STRING =
+	"^(entry|activity|exit)\\s*/\\s*([^\\n$]*)(\\n|$)";
 const TRIGGER_RE = new RegExp(TRIGGER_RE_AS_A_STRING);
 function stateExists(pKnownStateNames, pName) {
-    return pKnownStateNames.includes(pName);
+	return pKnownStateNames.includes(pName);
 }
 const RE2STATE_TYPE = [
-    {
-        re: /initial/,
-        stateType: "initial",
-    },
-    {
-        re: /final/,
-        stateType: "final",
-    },
-    {
-        re: /parallel/,
-        stateType: "parallel",
-    },
-    {
-        re: /(deep.*history)|(history.*deep)/,
-        stateType: "deephistory",
-    },
-    {
-        re: /history/,
-        stateType: "history",
-    },
-    {
-        re: /^\^.*/,
-        stateType: "choice",
-    },
-    {
-        re: /^].*/,
-        stateType: "forkjoin",
-    },
+	{
+		re: /initial/,
+		stateType: "initial",
+	},
+	{
+		re: /final/,
+		stateType: "final",
+	},
+	{
+		re: /parallel/,
+		stateType: "parallel",
+	},
+	{
+		re: /(deep.*history)|(history.*deep)/,
+		stateType: "deephistory",
+	},
+	{
+		re: /history/,
+		stateType: "history",
+	},
+	{
+		re: /^\^.*/,
+		stateType: "choice",
+	},
+	{
+		re: /^].*/,
+		stateType: "forkjoin",
+	},
 ];
 function matches(pName) {
-    return (pEntry) => pEntry.re.test(pName);
+	return (pEntry) => pEntry.re.test(pName);
 }
 function getStateType(pName) {
-    return (RE2STATE_TYPE.find(matches(pName)) || { stateType: "regular" })
-        .stateType;
+	return (RE2STATE_TYPE.find(matches(pName)) || { stateType: "regular" })
+		.stateType;
 }
 function initState(pName) {
-    return {
-        name: pName,
-        type: getStateType(pName),
-    };
+	return {
+		name: pName,
+		type: getStateType(pName),
+	};
 }
 function isComposite(pState) {
-    return Boolean(pState.statemachine);
+	return Boolean(pState.statemachine);
 }
 function getAlreadyDeclaredStates(pStateMachine) {
-    const lStates = pStateMachine?.states ?? [];
-    return lStates.filter(isComposite).reduce((pAllStateNames, pThisState) => pAllStateNames.concat(getAlreadyDeclaredStates(pThisState.statemachine)), lStates.map(({ name }) => name));
+	const lStates = pStateMachine?.states ?? [];
+	return lStates.filter(isComposite).reduce(
+		(pAllStateNames, pThisState) =>
+			pAllStateNames.concat(getAlreadyDeclaredStates(pThisState.statemachine)),
+		lStates.map(({ name }) => name),
+	);
 }
 function extractUndeclaredStates(pStateMachine, pKnownStateNames) {
-    pKnownStateNames = pKnownStateNames
-        ? pKnownStateNames
-        : getAlreadyDeclaredStates(pStateMachine);
-    pStateMachine.states = pStateMachine?.states ?? [];
-    const lTransitions = pStateMachine?.transitions ?? [];
-    pStateMachine.states.filter(isComposite).forEach((pState) => {
-        pState.statemachine.states = extractUndeclaredStates(pState.statemachine, pKnownStateNames);
-    });
-    lTransitions.forEach((pTransition) => {
-        if (!stateExists(pKnownStateNames, pTransition.from)) {
-            pKnownStateNames.push(pTransition.from);
-            pStateMachine.states.push(initState(pTransition.from));
-        }
-        if (!stateExists(pKnownStateNames, pTransition.to)) {
-            pKnownStateNames.push(pTransition.to);
-            pStateMachine.states.push(initState(pTransition.to));
-        }
-    });
-    return pStateMachine.states;
+	pKnownStateNames = pKnownStateNames
+		? pKnownStateNames
+		: getAlreadyDeclaredStates(pStateMachine);
+	pStateMachine.states = pStateMachine?.states ?? [];
+	const lTransitions = pStateMachine?.transitions ?? [];
+	pStateMachine.states.filter(isComposite).forEach((pState) => {
+		pState.statemachine.states = extractUndeclaredStates(
+			pState.statemachine,
+			pKnownStateNames,
+		);
+	});
+	lTransitions.forEach((pTransition) => {
+		if (!stateExists(pKnownStateNames, pTransition.from)) {
+			pKnownStateNames.push(pTransition.from);
+			pStateMachine.states.push(initState(pTransition.from));
+		}
+		if (!stateExists(pKnownStateNames, pTransition.to)) {
+			pKnownStateNames.push(pTransition.to);
+			pStateMachine.states.push(initState(pTransition.to));
+		}
+	});
+	return pStateMachine.states;
 }
 function classifyForkJoin(pInComingCount, pOutGoingCount) {
-    let lReturnValue = "junction";
-    if (pInComingCount <= 1 && pOutGoingCount > 1) {
-        lReturnValue = "fork";
-    }
-    if (pInComingCount > 1 && pOutGoingCount <= 1) {
-        lReturnValue = "join";
-    }
-    return lReturnValue;
-}
-function classifyForkJoins(pStateMachine, pFlattenedStateMachineModel = new StateMachineModel(pStateMachine)) {
-    pStateMachine.states = pStateMachine.states.map((pState) => {
-        if (pState.type === "forkjoin" && !pState.typeExplicitlySet) {
-            const lInComingCount = pFlattenedStateMachineModel.findTransitionsByTo(pState.name).length;
-            const lOutGoingCount = pFlattenedStateMachineModel.findTransitionsByFrom(pState.name).length;
-            pState.type = classifyForkJoin(lInComingCount, lOutGoingCount);
-        }
-        if (pState.statemachine) {
-            pState.statemachine = classifyForkJoins(pState.statemachine, pFlattenedStateMachineModel);
-        }
-        return pState;
-    });
-    return pStateMachine;
+	let lReturnValue = "junction";
+	if (pInComingCount <= 1 && pOutGoingCount > 1) {
+		lReturnValue = "fork";
+	}
+	if (pInComingCount > 1 && pOutGoingCount <= 1) {
+		lReturnValue = "join";
+	}
+	return lReturnValue;
+}
+function classifyForkJoins(
+	pStateMachine,
+	pFlattenedStateMachineModel = new StateMachineModel(pStateMachine),
+) {
+	pStateMachine.states = pStateMachine.states.map((pState) => {
+		if (pState.type === "forkjoin" && !pState.typeExplicitlySet) {
+			const lInComingCount = pFlattenedStateMachineModel.findTransitionsByTo(
+				pState.name,
+			).length;
+			const lOutGoingCount = pFlattenedStateMachineModel.findTransitionsByFrom(
+				pState.name,
+			).length;
+			pState.type = classifyForkJoin(lInComingCount, lOutGoingCount);
+		}
+		if (pState.statemachine) {
+			pState.statemachine = classifyForkJoins(
+				pState.statemachine,
+				pFlattenedStateMachineModel,
+			);
+		}
+		return pState;
+	});
+	return pStateMachine;
 }
 function stateEqual(pStateOne, pStateTwo) {
-    return pStateOne.name === pStateTwo.name;
+	return pStateOne.name === pStateTwo.name;
 }
 function uniq(pArray, pEqualFunction) {
-    return pArray.reduce((pBag, pMarble) => {
-        const lMarbleIndex = pBag.findIndex((pBagItem) => pEqualFunction(pBagItem, pMarble));
-        if (lMarbleIndex > -1) {
-            pBag[lMarbleIndex] = pMarble;
-            return pBag;
-        }
-        return pBag.concat(pMarble);
-    }, []);
+	return pArray.reduce((pBag, pMarble) => {
+		const lMarbleIndex = pBag.findIndex((pBagItem) =>
+			pEqualFunction(pBagItem, pMarble),
+		);
+		if (lMarbleIndex > -1) {
+			pBag[lMarbleIndex] = pMarble;
+			return pBag;
+		}
+		return pBag.concat(pMarble);
+	}, []);
 }
 function parseTransitionExpression(pString) {
-    const lTransitionExpressionRe = /([^[/]+)?(\[[^\]]+\])?[^/]*(\/.+)?/;
-    const lReturnValue = {};
-    const lMatchResult = pString.match(lTransitionExpressionRe);
-    const lEventPos = 1;
-    const lConditionPos = 2;
-    const lActionPos = 3;
-    if (lMatchResult[lEventPos]) {
-        lReturnValue.event = lMatchResult[lEventPos].trim();
-    }
-    if (lMatchResult[lConditionPos]) {
-        lReturnValue.cond = lMatchResult[lConditionPos].slice(1, -1).trim();
-    }
-    if (lMatchResult[lActionPos]) {
-        lReturnValue.action = lMatchResult[lActionPos]
-            .slice(1, lMatchResult[lActionPos].length)
-            .trim();
-    }
-    return lReturnValue;
+	const lTransitionExpressionRe = /([^[/]+)?(\[[^\]]+\])?[^/]*(\/.+)?/;
+	const lReturnValue = {};
+	const lMatchResult = pString.match(lTransitionExpressionRe);
+	const lEventPos = 1;
+	const lConditionPos = 2;
+	const lActionPos = 3;
+	if (lMatchResult[lEventPos]) {
+		lReturnValue.event = lMatchResult[lEventPos].trim();
+	}
+	if (lMatchResult[lConditionPos]) {
+		lReturnValue.cond = lMatchResult[lConditionPos].slice(1, -1).trim();
+	}
+	if (lMatchResult[lActionPos]) {
+		lReturnValue.action = lMatchResult[lActionPos]
+			.slice(1, lMatchResult[lActionPos].length)
+			.trim();
+	}
+	return lReturnValue;
 }
 function setIf(pObject, pProperty, pValue, pCondition = Boolean) {
-    if (pCondition(pValue)) {
-        pObject[pProperty] = pValue;
-    }
+	if (pCondition(pValue)) {
+		pObject[pProperty] = pValue;
+	}
 }
 function setIfNotEmpty(pObject, pProperty, pValue) {
-    setIf(pObject, pProperty, pValue, (pX) => pX && pX.length > 0);
+	setIf(pObject, pProperty, pValue, (pX) => pX && pX.length > 0);
 }
 function extractAction(pActivityCandidate) {
-    const lMatch = pActivityCandidate.match(TRIGGER_RE);
-    const lTypePos = 1;
-    const lBodyPos = 2;
-    if (lMatch) {
-        return {
-            type: lMatch[lTypePos],
-            body: lMatch[lBodyPos],
-        };
-    }
-    return {
-        type: "activity",
-        body: pActivityCandidate,
-    };
+	const lMatch = pActivityCandidate.match(TRIGGER_RE);
+	const lTypePos = 1;
+	const lBodyPos = 2;
+	if (lMatch) {
+		return {
+			type: lMatch[lTypePos],
+			body: lMatch[lBodyPos],
+		};
+	}
+	return {
+		type: "activity",
+		body: pActivityCandidate,
+	};
 }
 function extractActions(pString) {
-    return pString
-        .split(/\n\s*/g)
-        .map((pActivityCandidate) => pActivityCandidate.trim())
-        .map(extractAction);
+	return pString
+		.split(/\n\s*/g)
+		.map((pActivityCandidate) => pActivityCandidate.trim())
+		.map(extractAction);
 }
 export default {
-    initState,
-    extractUndeclaredStates,
-    classifyForkJoins,
-    getStateType,
-    stateEqual,
-    uniq,
-    parseTransitionExpression,
-    extractActions,
-    setIf,
-    setIfNotEmpty,
+	initState,
+	extractUndeclaredStates,
+	classifyForkJoins,
+	getStateType,
+	stateEqual,
+	uniq,
+	parseTransitionExpression,
+	extractActions,
+	setIf,
+	setIfNotEmpty,
 };