state-machine-cat 10.1.6 → 10.1.7

package/src/parse/parser-helpers.mjs

@@ -1,297 +0,0 @@
-// @ts-check
-/* eslint-disable security/detect-object-injection */
-import StateMachineModel from "../state-machine-model.mjs";
-
-const TRIGGER_RE_AS_A_STRING =
-  "^(entry|activity|exit)\\s*/\\s*([^\\n$]*)(\\n|$)";
-/* eslint security/detect-non-literal-regexp:0 */
-const TRIGGER_RE = new RegExp(TRIGGER_RE_AS_A_STRING);
-
-/**
- * @param {string[]} pKnownStateNames
- * @param {string} pName
- * @returns {boolean}
- */
-function stateExists(pKnownStateNames, pName) {
-  return pKnownStateNames.includes(pName);
-}
-/**
- * @type {{
- *   re:RegExp;
- *   stateType: import("../../types/state-machine-cat.js").StateType;
- * }[]}
- */
-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",
-  },
-];
-
-function matches(pName) {
-  return (pEntry) => pEntry.re.test(pName);
-}
-
-/**
- * @param {string} [pName]
- * @returns {import("../../types/state-machine-cat.js").StateType}
- */
-function getStateType(pName) {
-  return (RE2STATE_TYPE.find(matches(pName)) || { stateType: "regular" })
-    .stateType;
-}
-
-/**
- * @param {string} pName
- * @returns {import("../../types/state-machine-cat.js").IState}
- */
-function initState(pName) {
-  return {
-    name: pName,
-    type: getStateType(pName),
-  };
-}
-
-/**
- * @param {import("../../types/state-machine-cat.js").IState} pState
- * @returns {boolean}
- */
-function isComposite(pState) {
-  return Boolean(pState.statemachine);
-}
-
-/**
- * @param {import("../../types/state-machine-cat.js").IStateMachine} [pStateMachine]
- * @returns {string[]}
- */
-function getAlreadyDeclaredStates(pStateMachine) {
-  const lStates = pStateMachine?.states ?? [];
-
-  return lStates.filter(isComposite).reduce(
-    (pAllStateNames, pThisState) =>
-      pAllStateNames.concat(getAlreadyDeclaredStates(pThisState.statemachine)),
-    lStates.map(({ name }) => name)
-  );
-}
-
-/**
- * @param {import("../../types/state-machine-cat.js").IStateMachine} pStateMachine
- * @param {string[]} pKnownStateNames
- * @returns {import("../../types/state-machine-cat.js").IState[]}
- */
-function extractUndeclaredStates(pStateMachine, pKnownStateNames) {
-  pKnownStateNames = pKnownStateNames
-    ? pKnownStateNames
-    : getAlreadyDeclaredStates(pStateMachine);
-
-  pStateMachine.states = pStateMachine?.states ?? [];
-  const lTransitions = pStateMachine?.transitions ?? [];
-
-  pStateMachine.states.filter(isComposite).forEach((pState) => {
-    // @ts-expect-error isComposite guarantees the statemachine attribute exists, TS doesn't understand that yet, though
-    pState.statemachine.states = extractUndeclaredStates(
-      // @ts-expect-error isComposite guarantees the statemachine attribute exists, TS doesn't understand that yet, though
-      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;
-}
-
-/**
- * @param {number} pInComingCount
- * @param {number} pOutGoingCount
- * @returns {import("../../types/state-machine-cat.js").StateType}
- */
-function classifyForkJoin(pInComingCount, pOutGoingCount) {
-  /** @type {import("../../types/state-machine-cat.js").StateType} */
-  let lReturnValue = "junction";
-
-  if (pInComingCount <= 1 && pOutGoingCount > 1) {
-    lReturnValue = "fork";
-  }
-  if (pInComingCount > 1 && pOutGoingCount <= 1) {
-    lReturnValue = "join";
-  }
-
-  return lReturnValue;
-}
-
-/**
- * @param {import("../../types/state-machine-cat.js").IStateMachine} pStateMachine
- * @param {StateMachineModel} pFlattenedStateMachineModel
- * @returns {import("../../types/state-machine-cat.js").IStateMachine}
- */
-function classifyForkJoins(
-  pStateMachine,
-  pFlattenedStateMachineModel = new StateMachineModel(pStateMachine)
-) {
-  // TODO: mutates parameter
-  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;
-}
-
-/**
- * @param {import("../../types/state-machine-cat.js").IState} pStateOne
- * @param {import("../../types/state-machine-cat.js").IState} pStateTwo
- * @returns {boolean}
- */
-function stateEqual(pStateOne, pStateTwo) {
-  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) {
-      // ensures the _last_ marble we find is in the bag on that position
-      pBag[lMarbleIndex] = pMarble;
-      return pBag;
-    }
-    return pBag.concat(pMarble);
-  }, []);
-}
-
-/**
- * @param {String} pString
- * @returns {{event?: string; cond?: string; action?: string}}
- */
-function parseTransitionExpression(pString) {
-  // eslint-disable-next-line security/detect-unsafe-regex, unicorn/no-unsafe-regex
-  const lTransitionExpressionRe = /([^[/]+)?(\[[^\]]+\])?[^/]*(\/.+)?/;
-  const lReturnValue = {};
-
-  /** @type {RegExpMatchArray} */
-  // @ts-expect-error match has no fallback because lTransitionExpressionRe will match
-  // any string (every part is optional)
-  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 = (pX) => pX) {
-  if (pCondition(pValue)) {
-    pObject[pProperty] = pValue;
-  }
-}
-
-function setIfNotEmpty(pObject, pProperty, pValue) {
-  setIf(pObject, pProperty, pValue, (pX) => pX && pX.length > 0);
-}
-
-/**
- * @param {string} pActivityCandidate
- * @returns {{type: string; body: string}}
- */
-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,
-  };
-}
-
-/**
- * @param {string} pString
- * @returns {{type: string; body: string}[]}
- */
-function extractActions(pString) {
-  return pString
-    .split(/\n\s*/g)
-    .map((pActivityCandidate) => pActivityCandidate.trim())
-    .map(extractAction);
-}
-
-export default {
-  initState,
-  extractUndeclaredStates,
-  classifyForkJoins,
-  getStateType,
-  stateEqual,
-  uniq,
-  parseTransitionExpression,
-  extractActions,
-  setIf,
-  setIfNotEmpty,
-};

package/src/parse/scxml/normalize-machine.mjs

@@ -1,73 +0,0 @@
-import castArray from "lodash/castArray.js";
-
-/**
- * @param {Partial<import("./scxml").ISCXMLInitialState>} pInitialObject
- * @param {string} [pId]
- * @returns {import("./scxml").ISCXMLInitialState}
- */
-function normalizeInitialFromObject(pInitialObject, pId) {
-  const lReturnValue = {
-    // ensure the 'initial' state has a unique name
-    id: pId ? `${pId}.initial` : "initial",
-  };
-
-  if (pInitialObject.transition) {
-    Object.assign(lReturnValue, {
-      transition: [pInitialObject.transition],
-    });
-  }
-
-  return lReturnValue;
-}
-
-/**
- * @param {string} pString
- * @returns {import("./scxml").ISCXMLInitialState}
- */
-function normalizeInitialFromString(pString) {
-  return {
-    id: "initial",
-    transition: [
-      {
-        target: pString,
-      },
-    ],
-  };
-}
-
-/**
- * @param {any} pMachine
- * @returns {import("./scxml").ISCXMLInitialState[]}
- */
-function normalizeInitial(pMachine) {
-  const lReturnValue = [];
-
-  if (pMachine.initial) {
-    if (typeof pMachine.initial === "string") {
-      lReturnValue.push(normalizeInitialFromString(pMachine.initial));
-    } else {
-      lReturnValue.push(
-        normalizeInitialFromObject(pMachine.initial, pMachine.id)
-      );
-    }
-  }
-  return lReturnValue;
-}
-
-/**
- * Massages SCXML-as-json to be uniform:
- *
- * @param {any} pMachine SCXML-as-json state machine
- * @returns {import("./scxml").INormalizedSCXMLMachine} Still an SCXML-as-json state machine,
- * but more consistent and easier to use
- */
-export function normalizeMachine(pMachine) {
-  return {
-    ...pMachine,
-    initial: normalizeInitial(pMachine),
-    state: castArray(pMachine?.state ?? []),
-    parallel: castArray(pMachine?.parallel ?? []),
-    history: castArray(pMachine?.history ?? []),
-    final: castArray(pMachine?.final ?? []),
-  };
-}

package/src/parse/smcat-ast.schema.mjs

@@ -1,187 +0,0 @@
-export default {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  title: "state-machine-cat abstract syntax tree schema",
-  $ref: "#/definitions/StateMachineType",
-  $id: "org.js.state-machine-cat/v7.4.0",
-  definitions: {
-    StateType: {
-      type: "string",
-      enum: [
-        "regular",
-        "initial",
-        "terminate",
-        "final",
-        "parallel",
-        "history",
-        "deephistory",
-        "choice",
-        "forkjoin",
-        "fork",
-        "join",
-        "junction",
-      ],
-    },
-    TransitionType: {
-      type: "string",
-      enum: ["internal", "external"],
-    },
-    NoteType: {
-      type: "array",
-      items: {
-        type: "string",
-      },
-    },
-    ActionTypeType: {
-      type: "string",
-      enum: ["entry", "activity", "exit"],
-    },
-    ActionType: {
-      type: "object",
-      required: ["type", "body"],
-      additionalProperties: false,
-      properties: {
-        type: { $ref: "#/definitions/ActionTypeType" },
-        body: { type: "string" },
-      },
-    },
-    ClassType: {
-      type: "string",
-      pattern: "^[a-zA-Z0-9_\\- ]*$",
-    },
-    StateMachineType: {
-      type: "object",
-      additionalProperties: false,
-      required: ["states"],
-      properties: {
-        states: {
-          type: "array",
-          items: {
-            type: "object",
-            required: ["name", "type"],
-            additionalProperties: false,
-            properties: {
-              name: {
-                description:
-                  "The name and identifier of the state. Unique within the root state machine.",
-                type: "string",
-              },
-              type: {
-                description:
-                  "What kind of state (or pseudo state) this state is. E.g. 'regular' for normal states or 'initial', 'final', 'choice' etc for pseudo states. Most UML (pseudo-) states are supported.",
-                $ref: "#/definitions/StateType",
-              },
-              label: {
-                description:
-                  "The display label of the state. If it's not present, most renderers will use the states' name in stead.",
-                type: "string",
-              },
-              color: {
-                description:
-                  'Color to use for rendering the state. Accepts all css color names ("blue") and hex notation - with ("#0000FF77") or without ("#0000FF") transparency.',
-                type: "string",
-              },
-              class: {
-                description:
-                  "Class name to give the state in dot and svg output.",
-                $ref: "#/definitions/ClassType",
-              },
-              active: {
-                description:
-                  "If true the state is considered to be active and rendered as such.",
-                type: "boolean",
-              },
-              typeExplicitlySet: {
-                description:
-                  "The default parser derives the `type` from the `name` with inband signaling. The user can override that behavior by explicitly setting the `type`. This attribute is there to express that (and make sure that on next parses & processing it doesn't get accidentily re-derived from the name again).",
-                type: "boolean",
-              },
-              isComposite: {
-                description:
-                  "convenience, derived attribute - set to true if there's a state machine inside the state; false in all other cases. For internal use - @deprecated",
-                type: "boolean",
-              },
-              actions: {
-                type: "array",
-                description:
-                  "A series of actions and their types. The type describe when the action takes place (on entry, exit, or otherwise ('activity'))",
-                items: { $ref: "#/definitions/ActionType" },
-              },
-              note: {
-                description:
-                  "Comments related to this state. Some renderers will use the note attribute to render a note (i.e. as a post-it) attached to the state.",
-                $ref: "#/definitions/NoteType",
-              },
-              statemachine: {
-                description: "state machine nested within the state.",
-                $ref: "#/definitions/StateMachineType",
-              },
-            },
-          },
-        },
-        transitions: {
-          type: "array",
-          items: {
-            type: "object",
-            required: ["from", "to"],
-            additionalProperties: false,
-            properties: {
-              from: {
-                description:
-                  "The name of the state this transition transitions from",
-                type: "string",
-              },
-              to: {
-                description:
-                  "The name of the state this transition transitions to",
-                type: "string",
-              },
-              label: {
-                description:
-                  "A display label to represent this transition. Parsers can parse this label into events conditions and actions.",
-                type: "string",
-              },
-              event: {
-                description: "Event triggering the transition",
-                type: "string",
-              },
-              cond: {
-                description: "Condition for the transition to occur.",
-                type: "string",
-              },
-              action: {
-                description: "Action to execute when the transition occurs.",
-                type: "string",
-              },
-              note: {
-                description: "Comments related to this transition",
-                $ref: "#/definitions/NoteType",
-              },
-              color: {
-                description:
-                  'Color to use for rendering the transition. Accepts all css color names ("blue") and hex notation - with ("#0000FF77") or without ("#0000FF") transparency.',
-                type: "string",
-              },
-              width: {
-                description:
-                  "The line width to use for rendering the transition",
-                type: "number",
-                minimum: 0,
-                maximum: 30,
-              },
-              class: {
-                description:
-                  "Class name to give the state in dot and svg output.",
-                $ref: "#/definitions/ClassType",
-              },
-              type: {
-                description:
-                  "Whether the transition is external (default) or internal. See https://www.w3.org/TR/scxml/#transition for details.",
-                $ref: "#/definitions/TransitionType",
-              },
-            },
-          },
-        },
-      },
-    },
-  },
-};

package/src/render/dot/attributebuilder.mjs

@@ -1,68 +0,0 @@
-/* eslint-disable security/detect-object-injection */
-const GENERIC_GRAPH_ATTRIBUTES = [
-  { name: "fontname", value: '"Helvetica"' },
-  { name: "fontsize", value: "12" },
-  { name: "penwidth", value: "2.0" },
-];
-
-const GRAPH_ATTRIBUTES = {
-  dot: [
-    { name: "splines", value: "true" },
-    { name: "ordering", value: "out" },
-    { name: "compound", value: "true" },
-    { name: "overlap", value: "scale" },
-    { name: "nodesep", value: "0.3" },
-    { name: "ranksep", value: "0.1" },
-  ],
-  fdp: [{ name: "K", value: "0.9" }],
-  osage: [{ name: "pack", value: "42" }],
-  neato: [{ name: "epsilon", value: "0.9" }],
-};
-
-const DIRECTION_ATTRIBUTES = {
-  "bottom-top": [{ name: "rankdir", value: "BT" }],
-  "left-right": [{ name: "rankdir", value: "LR" }],
-  "right-left": [{ name: "rankdir", value: "RL" }],
-};
-
-const NODE_ATTRIBUTES = [
-  { name: "shape", value: "plaintext" },
-  { name: "style", value: "filled" },
-  { name: "fillcolor", value: '"#FFFFFF01"' },
-  { name: "fontname", value: "Helvetica" },
-  { name: "fontsize", value: 12 },
-  { name: "penwidth", value: "2.0" },
-];
-
-const EDGE_ATTRIBUTES = [
-  { name: "fontname", value: "Helvetica" },
-  { name: "fontsize", value: 10 },
-];
-
-function toNameValueString(pAttribute) {
-  return `${pAttribute.name}=${pAttribute.value}`;
-}
-
-export default {
-  /**
-   *
-   * @param {string} pEngine
-   * @param {string} pDirection
-   * @param {*} pDotGraphAttributes
-   * @returns {string}
-   */
-  buildGraphAttributes: (pEngine, pDirection, pDotGraphAttributes) =>
-    GENERIC_GRAPH_ATTRIBUTES.concat(GRAPH_ATTRIBUTES[pEngine] || [])
-      .concat(DIRECTION_ATTRIBUTES[pDirection] || [])
-      .concat(pDotGraphAttributes || [])
-      .map(toNameValueString)
-      .join(" "),
-  buildNodeAttributes: (pDotNodeAttributes) =>
-    NODE_ATTRIBUTES.concat(pDotNodeAttributes || [])
-      .map(toNameValueString)
-      .join(" "),
-  buildEdgeAttributes: (pDotEdgeAttributes) =>
-    EDGE_ATTRIBUTES.concat(pDotEdgeAttributes || [])
-      .map(toNameValueString)
-      .join(" "),
-};

package/src/render/dot/counter.mjs

@@ -1,33 +0,0 @@
-// @ts-check
-export default class Counter {
-  constructor() {
-    this.reset();
-  }
-
-  /**
-   * @returns {void}
-   */
-  reset() {
-    this.COUNTER = 0;
-  }
-
-  /**
-   * @returns {number}
-   */
-  next() {
-    // @ts-expect-error TS thinks COUNTER can possibly be null as it doesn't
-    // see that the function the constructor calls ensures it won't
-    // eslint-disable-next-line no-plusplus
-    return ++this.COUNTER;
-  }
-
-  /**
-   * @returns {string}
-   */
-  nextAsString() {
-    /** @type {number} */
-    const lBase = 10;
-
-    return this.next().toString(lBase);
-  }
-}