state-machine-cat 10.1.6 → 10.1.7

package/src/render/smcat/index.js

@@ -1,129 +0,0 @@
-// @ts-check
-/** @type {any} - the type definitions for Handlebars don't match what we're actually using - hence this override*/
-const Handlebars = require("handlebars/dist/handlebars.runtime.js");
-const cloneDeep = require("lodash/cloneDeep.js");
-
-// eslint-disable-next-line import/no-unassigned-import
-require("./smcat.template.js");
-
-/**
- * @typedef {{hasExtendedAttributes?: boolean} & import("../../../types/state-machine-cat.js").IState} IExtendedState
- * @typedef {{actions: string;} & Omit<IExtendedState, "actions">} IFlattenedActionsState
- */
-
-const NAME_QUOTABLE = /;|,|{| |\[/;
-const ACTIONS_QUOTABLE = /;|,|{/;
-const LABEL_QUOTABLE = /;|{/;
-
-/**
- * @param {RegExp} pRegExp
- * @param {string} pString
- * @returns {string}
- */
-function quoteIfNecessary(pRegExp, pString) {
-  return pRegExp.test(pString) ? `"${pString}"` : pString;
-}
-
-Handlebars.registerPartial(
-  "smcat.template.hbs",
-  Handlebars.templates["smcat.template.hbs"]
-);
-
-/**
- * @param {string} pString
- * @returns {string}
- */
-function formatActionType(pString) {
-  return pString === "activity" ? "" : `${pString}/ `;
-}
-
-/**
- * @param {IExtendedState} pState
- * @returns {IFlattenedActionsState}
- */
-function flattenActions(pState) {
-  return {
-    ...pState,
-    actions: (pState.actions || [])
-      .map((pAction) => `${formatActionType(pAction.type)}${pAction.body}`)
-      .join("\n    "),
-  };
-}
-
-/**
- * @param {IExtendedState} pState
- * @returns {IExtendedState}
- */
-/* eslint complexity:0 */
-function flagExtendedStateAttributes(pState) {
-  if (
-    Object.prototype.hasOwnProperty.call(pState, "label") ||
-    Object.prototype.hasOwnProperty.call(pState, "typeExplicitlySet") ||
-    Object.prototype.hasOwnProperty.call(pState, "color") ||
-    Object.prototype.hasOwnProperty.call(pState, "active") ||
-    Object.prototype.hasOwnProperty.call(pState, "class")
-  ) {
-    // note & fixme: mutating a parameter here
-    pState.hasExtendedAttributes = true;
-  }
-  return pState;
-}
-
-/**
- * @param {import("../../../types/state-machine-cat.js").IState[]} pStates
- * @returns {IFlattenedActionsState[]}
- */
-function transformStates(pStates) {
-  pStates
-    .map(flagExtendedStateAttributes)
-    .filter((pState) => pState.statemachine)
-    .forEach((pState) => {
-      // @ts-expect-error because of the filter above the statemachine is
-      // sure to exist, although TS currently doesn't detect this.
-      // also fixme: mutating a parameter here
-      pState.statemachine.states = transformStates(
-        // @ts-expect-error - see above
-        pState.statemachine.states
-      );
-    });
-
-  return pStates.map(flattenActions);
-}
-
-function flagExtendedTransitionAttributes(pTransition) {
-  if (
-    Object.prototype.hasOwnProperty.call(pTransition, "type") ||
-    Object.prototype.hasOwnProperty.call(pTransition, "color") ||
-    Object.prototype.hasOwnProperty.call(pTransition, "class")
-  ) {
-    pTransition.hasExtendedAttributes = true;
-  }
-  return pTransition;
-}
-
-function transformTransitions(pTransitions) {
-  return pTransitions.map(flagExtendedTransitionAttributes);
-}
-
-Handlebars.registerHelper("quotifyState", (pItem) =>
-  quoteIfNecessary(NAME_QUOTABLE, pItem)
-);
-
-Handlebars.registerHelper("quotifyLabel", (pItem) =>
-  quoteIfNecessary(LABEL_QUOTABLE, pItem)
-);
-
-Handlebars.registerHelper("quotifyActions", (pItem) =>
-  quoteIfNecessary(ACTIONS_QUOTABLE, pItem)
-);
-
-/** @type {import("../../../types/state-machine-cat.js").StringRenderFunctionType} */
-module.exports = function renderSmcat(pStateMachine) {
-  return Handlebars.templates["smcat.template.hbs"]({
-    ...pStateMachine,
-    states: transformStates(cloneDeep(pStateMachine.states)),
-    transitions: transformTransitions(
-      cloneDeep(pStateMachine.transitions || [])
-    ),
-  });
-};

package/src/render/vector/dot-to-vector-native.mjs

@@ -1,60 +0,0 @@
-import { spawnSync } from "node:child_process";
-
-const DEFAULT_OPTIONS = {
-  exec: "dot",
-  format: "svg",
-};
-
-/**
- * Takes a graphviz dot program (as a string), runs it through the dot
- * executable specified in pOptions.exec (default: 'dot') and returns
- * the result
- *
- * @param  {string} pDot        The dot program as a string
- * @param  {{exec: string, format: import("../../../types/state-machine-cat").OutputType}} pOptions
- *         exec: the path to the executable to run. Default: 'dot'
- * @return {string} the dot program converted into an svg
- * @throws {Error} when something ontowards has happened (executable not found, erroneous dot program)
- */
-function convert(pDot, pOptions) {
-  const lOptions = {
-    ...DEFAULT_OPTIONS,
-    ...pOptions,
-  };
-  const { stdout, status, error } = spawnSync(
-    lOptions.exec,
-    [`-T${lOptions.format}`],
-    {
-      // cwd: lOptions.workingDirectory,
-      input: pDot,
-    }
-  );
-
-  //  0: okeleedokelee
-  //  1: error in the program
-  // -2: executable not found
-  if (status === 0) {
-    return stdout.toString("binary");
-  } else if (error) {
-    throw new Error(error);
-  } else {
-    throw new Error(`Unexpected error occurred. Exit code ${status}`);
-  }
-}
-
-function isAvailable(pOptions) {
-  const lOptions = {
-    ...DEFAULT_OPTIONS,
-    ...pOptions,
-  };
-  const { status, stderr } = spawnSync(lOptions.exec, ["-V"]);
-
-  return (
-    status === 0 && stderr.toString("utf8").startsWith("dot - graphviz version")
-  );
-}
-
-export default {
-  convert,
-  isAvailable,
-};

package/src/render/vector/vector-native-dot-with-fallback.mjs

@@ -1,55 +0,0 @@
-import dotToSvgJs from "viz.js";
-import indentString from "indent-string";
-import wrapAnsi from "wrap-ansi";
-import chalk from "chalk";
-import options from "../../options.mjs";
-import ast2dot from "../dot/index.mjs";
-import dotToVectorNative from "./dot-to-vector-native.mjs";
-
-const DEFAULT_INDENT = 2;
-const DOGMATIC_CONSOLE_WIDTH = 78;
-const VIZ_JS_UNSUPPORTED_OUTPUT_FORMATS = ["pdf", "png"];
-
-/** @type {import("../../../types/state-machine-cat.js").StringRenderFunctionType} */
-export default (pStateMachine, pOptions) => {
-  const lDotProgram = ast2dot(pStateMachine, pOptions);
-  const lDotOptions = {
-    engine: options.getOptionValue(pOptions, "engine"),
-    format: options.getOptionValue(pOptions, "outputType"),
-  };
-
-  if (dotToVectorNative.isAvailable(pOptions)) {
-    return dotToVectorNative.convert(lDotProgram, lDotOptions);
-  } else {
-    if (VIZ_JS_UNSUPPORTED_OUTPUT_FORMATS.includes(lDotOptions.format)) {
-      throw new Error(
-        "GraphViz 'dot' executable not found. Falling back to viz.js.\n\n" +
-          "'viz.js' doesn't support the 'pdf' and 'png' output formats. Either " +
-          "select a format that it does support or install GraphViz " +
-          "(recommended), which has support for both formats.\n"
-      );
-    }
-
-    process.stderr.write(
-      indentString(
-        wrapAnsi(
-          `\n${chalk.yellow(
-            "warning:"
-          )} GraphViz 'dot' executable not found. Falling back to viz.js.\n\n` +
-            "On node >=12 this fallback will trigger a warning from the " +
-            `node runtime:\n${chalk.italic(
-              "Invalid asm.js: Function definition doesn't match use"
-            )}.\n` +
-            "It's harmless and the svg will generate just fine. However, if " +
-            "you want to avoid the warning install GraphViz and make sure it's " +
-            "available in your path." +
-            "\n\n",
-          DOGMATIC_CONSOLE_WIDTH
-        ),
-        DEFAULT_INDENT
-      )
-    );
-
-    return dotToSvgJs(lDotProgram, lDotOptions);
-  }
-};

package/src/render/vector/vector-with-viz-js.mjs

@@ -1,18 +0,0 @@
-import viz from "viz.js";
-import options from "../../options.mjs";
-import ast2dot from "../dot/index.mjs";
-
-const OUTPUT_TYPE2FORMAT = {
-  oldsvg: "svg",
-  oldps2: "ps2",
-  oldeps: "eps",
-};
-
-/** @type {import("../../../types/state-machine-cat.js").StringRenderFunctionType} */
-export default (pStateMachine, pOptions) =>
-  viz(ast2dot(pStateMachine, pOptions), {
-    engine: options.getOptionValue(pOptions, "engine"),
-    format:
-      OUTPUT_TYPE2FORMAT[options.getOptionValue(pOptions, "outputType")] ||
-      "svg",
-  });

package/src/state-machine-model.mjs

@@ -1,124 +0,0 @@
-// @ts-check
-/**
- * @param {import("../types/state-machine-cat").IState[]} pStates
- * @param {boolean} pHasParent
- * @returns {any} // IFlattenedState  - a state, but flattened (statemachine is a boolean, the new attr hasParent as well)
- */
-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(
-          // @ts-expect-error TS doesn't detect that after the call in the filter
-          // the .statemachine is guaranteed to exist
-          flattenStates(pState.statemachine.states, true)
-        );
-      }
-    });
-
-  return lReturnValue.concat(
-    pStates.map((pState) => ({
-      name: pState.name,
-      type: pState.type,
-      statemachine: Boolean(pState.statemachine),
-      hasParent: pHasParent,
-    }))
-  );
-}
-
-/**
- * @param {import("../types/state-machine-cat").IStateMachine} pStateMachine
- * @returns {import("../types/state-machine-cat").ITransition[]}
- */
-function flattenTransitions(pStateMachine) {
-  /** @type {import("../types/state-machine-cat").ITransition[]} */
-  let lTransitions = [];
-
-  if (Object.prototype.hasOwnProperty.call(pStateMachine, "transitions")) {
-    // @ts-expect-error TS doesn't detect that after the call in the if the
-    // .transitions is guaranteed to exist
-    lTransitions = pStateMachine.transitions;
-  }
-  if (Object.prototype.hasOwnProperty.call(pStateMachine, "states")) {
-    pStateMachine.states
-      .filter((pState) => Boolean(pState.statemachine))
-      .forEach((pState) => {
-        lTransitions = lTransitions.concat(
-          // @ts-expect-error TS doesn't detect that after the call in the filter
-          // the .statemachine is guaranteed to exist
-          flattenTransitions(pState.statemachine)
-        );
-      });
-  }
-  return lTransitions;
-}
-
-export default class StateMachineModel {
-  /**
-   * @param {import("../types/state-machine-cat").IStateMachine} pStateMachine
-   */
-  constructor(pStateMachine) {
-    this._flattenedStates = flattenStates(pStateMachine.states || []);
-    this._flattenedTransitions = flattenTransitions(pStateMachine);
-  }
-  /**
-   * @returns {import("../types/state-machine-cat").ITransition[]}
-   */
-  get flattenedTransitions() {
-    return this._flattenedTransitions;
-  }
-
-  /**
-   * @param {string} pName
-   * @returns {any} // IFlattenedState
-   */
-  findStateByName(pName) {
-    return this._flattenedStates.find((pState) => pState.name === pName);
-  }
-
-  /**
-   * @param {import("../types/state-machine-cat").StateType[]} pTypes
-   * @returns {any} // IFlattenedState
-   */
-  findStatesByTypes(pTypes) {
-    return this._flattenedStates.filter((pState) =>
-      pTypes.includes(pState.type)
-    );
-  }
-
-  /**
-   * @param {string} pStateName
-   * @returns {import("../types/state-machine-cat").ITransition[]}
-   */
-  findExternalSelfTransitions(pStateName) {
-    return this._flattenedTransitions.filter(
-      (pTransition) =>
-        pTransition.from === pStateName &&
-        pTransition.to === pStateName &&
-        pTransition.type !== "internal"
-    );
-  }
-
-  /**
-   * @param {string} pFromStateName
-   * @returns {import("../types/state-machine-cat").ITransition[]}
-   */
-  findTransitionsByFrom(pFromStateName) {
-    return this._flattenedTransitions.filter(
-      (pTransition) => pTransition.from === pFromStateName
-    );
-  }
-
-  /**
-   * @param {string} pToStateName
-   * @returns {import("../types/state-machine-cat").ITransition[]}
-   */
-  findTransitionsByTo(pToStateName) {
-    return this._flattenedTransitions.filter(
-      (pTransition) => pTransition.to === pToStateName
-    );
-  }
-}

package/src/transform/desugar.mjs

@@ -1,222 +0,0 @@
-// @ts-check
-/* eslint-disable security/detect-object-injection */
-import cloneDeep from "lodash/cloneDeep.js";
-import reject from "lodash/reject.js";
-import StateMachineModel from "../state-machine-model.mjs";
-import utl from "./utl.mjs";
-
-/**
- * @typedef {{[stateName: string]: import("../../types/state-machine-cat.js").ITransition[]}} ITransitionMap
- */
-
-/**
- * @param {string|undefined} pIncomingThing
- * @param {string} pOutgoingThing
- * @param {string} pJoinChar
- * @returns {string}
- */
-function fuseTransitionAttribute(pIncomingThing, pOutgoingThing, pJoinChar) {
-  return pIncomingThing
-    ? `${pIncomingThing}${pJoinChar}${pOutgoingThing}`
-    : pOutgoingThing;
-}
-
-/**
- * @param {import("../../types/state-machine-cat.js").ITransition} pIncomingTransition
- * @param {import("../../types/state-machine-cat.js").ITransition} pOutgoingTransition
- * @returns {import("../../types/state-machine-cat.js").ITransition}
- */
-function fuseIncomingToOutgoing(pIncomingTransition, pOutgoingTransition) {
-  // in:
-  // a => ]: event [condition]/ action;
-  // ] => b: event_to_b [condition_to_b]/ action to b;
-  //
-  // out:
-  // a => b: event [condition]/ action\naction to b;
-  //
-  // events and conditions are illegal on transitions outgoing
-  // from forks, so we ignore them
-  /** @type {import("../../types/state-machine-cat.js").ITransition} */
-  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;
-}
-
-/**
- * @param {import("../../types/state-machine-cat.js").ITransition[]} pTransitions
- * @param {string[]} pPseudoStateNames
- * @param {ITransitionMap} pOutgoingTransitionMap
- * @returns {import("../../types/state-machine-cat.js").ITransition[]}
- */
-function fuseTransitions(
-  pTransitions,
-  pPseudoStateNames,
-  pOutgoingTransitionMap
-) {
-  return pTransitions.reduce(
-    /**
-     * @param {import("../../types/state-machine-cat.js").ITransition[]} pAll
-     * @param {import("../../types/state-machine-cat.js").ITransition} pTransition
-     * @returns {import("../../types/state-machine-cat.js").ITransition[]}
-     */
-    (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;
-    },
-    []
-  );
-}
-
-/**
- * @param {import("../../types/state-machine-cat.js").IStateMachine} pMachine
- * @param {string[]} pPseudoStateNames
- * @param {ITransitionMap} pOutgoingTransitionMap
- * @returns {import("../../types/state-machine-cat.js").IStateMachine}
- */
-function deSugarPseudoStates(
-  pMachine,
-  pPseudoStateNames,
-  pOutgoingTransitionMap
-) {
-  const lMachine = cloneDeep(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;
-}
-
-/**
- * @param {import("../../types/state-machine-cat.js").IStateMachine} pMachine
- * @param {string[]} pStateNames
- * @returns {import("../../types/state-machine-cat.js").IStateMachine}
- */
-function removeStatesCascading(pMachine, pStateNames) {
-  const lMachine = cloneDeep(pMachine);
-
-  if (lMachine.transitions) {
-    lMachine.transitions = reject(lMachine.transitions, (pTransition) =>
-      pStateNames.some(
-        (pJunctionStateName) =>
-          pJunctionStateName === pTransition.from ||
-          pJunctionStateName === pTransition.to
-      )
-    );
-  }
-
-  lMachine.states = reject(lMachine.states, (pState) =>
-    pStateNames.includes(pState.name)
-  ).map((pState) =>
-    pState.statemachine
-      ? {
-          ...pState,
-          statemachine: removeStatesCascading(pState.statemachine, pStateNames),
-        }
-      : pState
-  );
-  return lMachine;
-}
-
-/**
- * Takes a state machine and replaces all forks with transitions from its
- * respective inputs and outputs
- *
- * e.g.
- * ```smcat
- * a => ];
- * b => ];
- * ] => c;
- * ] => d;
- * ```
- *
- * will become
- * ```smcat
- * a => c;
- * a => d;
- * b => c;
- * b => d;
- * ```
- *
- * @param {import("../../types/state-machine-cat.js").IStateMachine} pMachine The state machine still containing forks
- * @param {import("../../types/state-machine-cat.js").StateType[]} pDesugarableStates array of de-sugarable states
- * @returns {import("../../types/state-machine-cat.js").IStateMachine} the transformed state machine
- */
-export default (
-  pMachine,
-  pDesugarableStates = ["fork", "junction", "choice"]
-) => {
-  const lModel = new StateMachineModel(pMachine);
-
-  /** @type {string[]} */
-  const lPseudoStateNames = lModel
-    .findStatesByTypes(pDesugarableStates)
-    .map(({ name }) => name);
-
-  /** @type {ITransitionMap} */
-  const lOutgoingTransitionMap = lPseudoStateNames.reduce(
-    (pAll, pStateName) => {
-      pAll[pStateName] = lModel.findTransitionsByFrom(pStateName);
-      return pAll;
-    },
-    {}
-  );
-
-  const lMachine = deSugarPseudoStates(
-    pMachine,
-    lPseudoStateNames,
-    lOutgoingTransitionMap
-  );
-
-  return removeStatesCascading(lMachine, lPseudoStateNames);
-};

package/src/transform/utl.mjs

@@ -1,26 +0,0 @@
-// @ts-check
-/**
- *
- * @param {string} [pEvent]
- * @param {string} [pCond]
- * @param {string} [pActions]
- * @returns {string}
- */
-function formatLabel(pEvent, pCond, pActions) {
-  let lReturnValue = "";
-
-  if (pEvent) {
-    lReturnValue += pEvent;
-  }
-  if (pCond) {
-    lReturnValue += ` [${pCond}]`;
-  }
-  if (pActions) {
-    lReturnValue += `/ ${pActions}`;
-  }
-  return lReturnValue.trim();
-}
-
-export default {
-  formatLabel,
-};

package/src/version.mjs

@@ -1,2 +0,0 @@
-// generated by tools/get-version.mjs - edits will be overwritten
-export const version = "10.1.6";