state-machine-cat 10.1.6 → 10.1.7

package/src/cli/normalize.mjs

@@ -1,204 +0,0 @@
-// @ts-check
-/* eslint-disable security/detect-object-injection, no-inline-comments */
-import path from "node:path";
-import options from "../options.mjs";
-import { parse as parseAttributes } from "./attributes-parser.mjs";
-
-/**
- * @typedef {{[extension: string]: string}} DictionaryType
- */
-
-const INPUT_EXTENSIONS = {
-  ".smcat": "smcat",
-  ".scxml": "scxml",
-  ".xml": "scxml",
-  ".json": "json",
-  ".ast": "json",
-};
-
-const OUTPUT_EXTENSIONS = {
-  ".ast": "json",
-  ".dot": "dot",
-  ".eps": "eps",
-  ".json": "json",
-  ".pdf": "pdf",
-  ".png": "png",
-  ".ps": "ps",
-  ".ps2": "ps2",
-  ".scjson": "scjson",
-  ".scxml": "scxml",
-  ".smcat": "smcat",
-  ".svg": "svg",
-};
-
-/**
- * Given a filename in pString, returns what language is probably
- * contained in that file, judging from the extension (the last dot
- * in the string to end-of-string)
- *
- * When in doubt returns pDefault
- *
- * @param {string} pString - filename
- * @param {DictionaryType} pExtensionMap - a dictionary with
- *        extension : classification pairs
- * @param {string} pDefault - the default to return when the extension
- *        does not occur in the extension map
- * @return  {string} - language. Possible values: LHS of the passed
- *        extension map.
- */
-function classifyExtension(pString, pExtensionMap, pDefault) {
-  return pExtensionMap[path.extname(pString)] || pDefault;
-}
-
-/**
- * @param {import("../..").OutputType} pOutputType
- * @returns {import("../..").OutputType}
- */
-function outputType2Extension(pOutputType) {
-  const lExceptions = {
-    oldeps: "eps",
-    oldps: "ps",
-    oldps2: "ps",
-    oldsvg: "svg",
-    ps2: "ps",
-  };
-  return lExceptions[pOutputType] || pOutputType;
-}
-
-/**
- * @param {string} pInputFrom
- * @param {import("../..").OutputType} pOutputType
- * @returns {string}
- */
-function deriveOutputFromInput(pInputFrom, pOutputType) {
-  const lExtension = outputType2Extension(pOutputType);
-
-  if (!pInputFrom || "-" === pInputFrom) {
-    return "-";
-  }
-  return path
-    .join(
-      path.dirname(pInputFrom),
-      path.basename(pInputFrom, path.extname(pInputFrom))
-    )
-    .concat(".")
-    .concat(lExtension);
-}
-
-/**
- * @param {string|undefined} pOutputTo
- * @param {string} pInputFrom
- * @param {import("../..").OutputType} pOutputType
- * @returns {string}
- */
-function determineOutputTo(pOutputTo, pInputFrom, pOutputType) {
-  return pOutputTo ? pOutputTo : deriveOutputFromInput(pInputFrom, pOutputType);
-}
-
-/**
- * @param {string} pInputFrom
- * @param {import("../..").InputType} [pInputType]
- * @returns {import("../..").InputType}
- */
-function determineInputType(pInputFrom, pInputType) {
-  if (pInputType) {
-    return pInputType;
-  }
-  // @ts-expect-error we can safely cast this to InputType. classifyExtension
-  // can probably use treatment with a generic, but with jsdoc annotations
-  // if at all possible would likely be awkward.
-  return classifyExtension(
-    pInputFrom,
-    INPUT_EXTENSIONS,
-    options.getAllowedValues().inputType.default
-  );
-}
-/**
- *
- * @param {string} [pOutputTo]
- * @param {import("../..").OutputType} [pOutputType]
- * @returns {import("../..").OutputType}
- */
-function determineOutputType(pOutputTo, pOutputType) {
-  if (pOutputType) {
-    return pOutputType;
-  }
-  if (pOutputTo) {
-    // @ts-expect-error we can safely cast this to OutputType. classifyExtension
-    // can probably use treatment with a generic, but with jsdoc annotations
-    // if at all possible would likely be awkward.
-    return classifyExtension(
-      pOutputTo,
-      OUTPUT_EXTENSIONS,
-      options.getAllowedValues().outputType.default
-    );
-  }
-  // @ts-expect-error cast to OutputType is safe - see above
-  return options.getAllowedValues().outputType.default;
-}
-/**
- *
- * @param {import("./cli").ILooseCLIRenderOptions} pOptions
- * @param {string} pParameter
- * @returns string
- */
-function determineParameter(pOptions, pParameter) {
-  return Object.prototype.hasOwnProperty.call(pOptions, pParameter)
-    ? pOptions[pParameter]
-    : options.getAllowedValues()[pParameter].default;
-}
-
-/**
- * @param {Partial<import("./cli").ILooseCLIRenderOptions>} pOptions
- * @param {keyof import("./cli").ILooseCLIRenderOptions} pDotAttributes
- * @returns {import("../..").dotAttributesType}
- */
-function determineDotAttributes(pOptions, pDotAttributes) {
-  return Boolean(pOptions?.[pDotAttributes]) &&
-    typeof pOptions[pDotAttributes] === "string"
-    ? // @ts-expect-error parseAttributes expects a string - which we can guarantee (see above) - but tsc can't/ doesn't see it
-      parseAttributes(pOptions[pDotAttributes])
-    : [];
-}
-
-/**
- * transforms the given argument and options to a uniform format
- *
- * - guesses the input type when not given
- * - guesses the output type when not given
- * - guesses the filename to output to when not given
- * - translates parserOutput to a regular output type
- *
- * @param  {string} pArgument an argument (containing the filename to parse)
- * @param  {import("./cli").ILooseCLIRenderOptions} pLooseOptions
- * @return {import("./cli").ICLIRenderOptions}
- *          the passed options object, but normalized
- */
-export default function normalize(pArgument = "-", pLooseOptions = {}) {
-  const lNormalizedInputFrom = pArgument || "-";
-  const lNormalizedInputType = determineInputType(
-    lNormalizedInputFrom,
-    pLooseOptions.inputType
-  );
-  const lNormalizedOutputType = determineOutputType(
-    pLooseOptions.outputTo,
-    pLooseOptions.outputType
-  );
-
-  return {
-    inputFrom: lNormalizedInputFrom,
-    inputType: lNormalizedInputType,
-    outputType: lNormalizedOutputType,
-    outputTo: determineOutputTo(
-      pLooseOptions.outputTo,
-      lNormalizedInputFrom,
-      lNormalizedOutputType
-    ),
-    engine: determineParameter(pLooseOptions, "engine"),
-    direction: determineParameter(pLooseOptions, "direction"),
-    dotGraphAttrs: determineDotAttributes(pLooseOptions, "dotGraphAttrs"),
-    dotNodeAttrs: determineDotAttributes(pLooseOptions, "dotNodeAttrs"),
-    dotEdgeAttrs: determineDotAttributes(pLooseOptions, "dotEdgeAttrs"),
-    desugar: pLooseOptions?.desugar ?? false,
-  };
-}

package/src/cli/validations.mjs

@@ -1,140 +0,0 @@
-// @ts-check
-import fs from "node:fs";
-import smcat from "../index-node.mjs";
-import { parse as parseAttributes } from "./attributes-parser.mjs";
-
-const allowedValues = smcat.getAllowedValues();
-
-/**
- * @param {{name: string}} pValue
- * @returns {string}
- */
-function getName(pValue) {
-  return pValue.name;
-}
-
-const VALID_OUTPUT_TYPES = allowedValues.outputType.values.map(getName);
-const VALID_INPUT_TYPES = allowedValues.inputType.values.map(getName);
-const VALID_ENGINES = allowedValues.engine.values.map(getName);
-const VALID_DIRECTIONS = allowedValues.direction.values.map(getName);
-
-/**
- * @param {string} pFilename
- * @returns {boolean}
- */
-function isStdout(pFilename) {
-  return "-" === pFilename;
-}
-
-/**
- * @param {string} pFilename
- * @returns {boolean}
- */
-function fileExists(pFilename) {
-  try {
-    if (!isStdout(pFilename)) {
-      fs.accessSync(pFilename, fs.constants.R_OK);
-    }
-    return true;
-  } catch (pError) {
-    return false;
-  }
-}
-
-/**
- * This function is shaped so it can serve as a validation function in a
- * commander option.
- *
- * @param {keyof import("../../types/state-machine-cat").IRenderOptions} pOption
- * @param {string[]} pValidValues
- * @param {string} pError
- * @returns {never|keyof import("../../types/state-machine-cat").IRenderOptions}
- */
-function validOption(pOption, pValidValues, pError) {
-  if (pValidValues.includes(pOption)) {
-    return pOption;
-  }
-
-  throw new Error(pError);
-}
-
-export default {
-  validOutputType: (pType) =>
-    validOption(
-      pType,
-      VALID_OUTPUT_TYPES,
-      `\n  error: '${pType}' is not a valid output type. smcat can emit:` +
-        `\n          ${VALID_OUTPUT_TYPES.join(", ")}\n\n`
-    ),
-
-  validInputType: (pType) =>
-    validOption(
-      pType,
-      VALID_INPUT_TYPES,
-      `\n  error: '${pType}' is not a valid input type.` +
-        `\n         smcat can read ${VALID_INPUT_TYPES.join(", ")}\n\n`
-    ),
-
-  validEngine: (pEngine) =>
-    validOption(
-      pEngine,
-      VALID_ENGINES,
-      `\n  error: '${pEngine}' is not a valid input type.` +
-        `\n         you can choose from ${VALID_ENGINES.join(", ")}\n\n`
-    ),
-
-  validDirection: (pDirection) =>
-    validOption(
-      pDirection,
-      VALID_DIRECTIONS,
-      `\n  error: '${pDirection}' is not a valid direction.` +
-        `\n         you can choose from ${VALID_DIRECTIONS.join(", ")}\n\n`
-    ),
-
-  validDotAttrs: (pDotAttributes) => {
-    try {
-      parseAttributes(pDotAttributes);
-      return pDotAttributes;
-    } catch (pError) {
-      throw new Error(`Invalid dot attributes: ${pError.message}`);
-    }
-  },
-
-  /**
-   * @param {import("./cli").ICLIRenderOptions} pOptions
-   * @returns {never|import("./cli").ICLIRenderOptions}
-   */
-  validateArguments(pOptions) {
-    if (!pOptions.inputFrom) {
-      throw new Error(`\n  error: Please specify an input file.\n\n`);
-    }
-
-    if (!pOptions.outputTo) {
-      throw new Error(`\n  error: Please specify an output file.\n\n`);
-    }
-
-    if (!fileExists(pOptions.inputFrom)) {
-      throw new Error(
-        `\n  error: Failed to open input file '${pOptions.inputFrom}'\n\n`
-      );
-    }
-
-    return pOptions;
-  },
-
-  validOutputTypeRE: VALID_OUTPUT_TYPES.join("|"),
-
-  defaultOutputType: allowedValues.outputType.default,
-
-  validInputTypeRE: VALID_INPUT_TYPES.join("|"),
-
-  defaultInputType: allowedValues.inputType.default,
-
-  validEngineRE: VALID_ENGINES.join("|"),
-
-  defaultEngine: allowedValues.engine.default,
-
-  validDirectionRE: VALID_DIRECTIONS.join("|"),
-
-  defaultDirection: allowedValues.direction.default,
-};

package/src/index-node.mjs

@@ -1,55 +0,0 @@
-// @ts-check
-import options from "./options.mjs";
-import parse from "./parse/index.mjs";
-import desugar from "./transform/desugar.mjs";
-import getRenderFunction from "./render/index-node.mjs";
-import { version } from "./version.mjs";
-
-export default {
-  /**
-   * Translates the input script to an output-script.
-   *
-   * @param  {string|import("../types/state-machine-cat").IStateMachine} pScript
-   *                              The script to translate
-   * @param  {import("../types/state-machine-cat").IRenderOptions} pOptions
-   *                              options influencing parsing & rendering.
-   * @throws {Error}              if an error occurred and no callback
-   *                              function was passed: the error
-   *
-   * Options: see https://github.com/sverweij/state-machine-cat/docs/api.md
-   *
-   */
-  render(pScript, pOptions) {
-    const lStateMachine = parse.getAST(pScript, pOptions);
-    const lDesugar = options.getOptionValue(pOptions, "desugar");
-
-    // @ts-expect-error should be cast to OutputTypeType - or the getOptionValue
-    // function should be refactored to be more explicit in type it returns
-    // when we ask for outputType
-    return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(
-      lDesugar ? desugar(lStateMachine) : lStateMachine,
-      pOptions
-    );
-  },
-
-  /**
-   * The current (semver compliant) version number string of
-   * state machine cat
-   *
-   * @type {string}
-   */
-  version,
-
-  /**
-   * Returns an object with each of the options you can pass to
-   * the render function
-   * - the default value
-   * - the possible values in an array of objects, each of which
-   *   has the properties:
-   *   - name: the value
-   * @returns {import("../types/state-machine-cat").IAllowedValues}
-   */
-  getAllowedValues() {
-    return options.getAllowedValues();
-  },
-};

package/src/index.mjs

@@ -1,58 +0,0 @@
-// @ts-check
-/* eslint-disable budapestian/global-constant-pattern */
-import options from "./options.mjs";
-import parse from "./parse/index.mjs";
-import desugar from "./transform/desugar.mjs";
-import getRenderFunction from "./render/index.mjs";
-import { version as _version } from "./version.mjs";
-
-/**
- * Translates the input script to an output-script.
- *
- * @param  {string|import("../types/state-machine-cat").IStateMachine} pScript
- *                              The script to translate
- * @param  {import("../types/state-machine-cat").IRenderOptions} pOptions
- *                              options influencing parsing & rendering.
- * @return {string}
- * @throws {Error}              if an error occurred and no callback
- *                              function was passed: the error
- *
- * Options: see https://github.com/sverweij/state-machine-cat/docs/api.md
- *
- */
-export function render(pScript, pOptions) {
-  const lStateMachine = parse.getAST(pScript, pOptions);
-  const lDesugar = options.getOptionValue(pOptions, "desugar");
-
-  return getRenderFunction(options.getOptionValue(pOptions, "outputType"))(
-    lDesugar ? desugar(lStateMachine) : lStateMachine,
-    pOptions
-  );
-}
-
-/**
- * The current (semver compliant) version number string of
- * state machine cat
- *
- * @type {string}
- */
-export const version = _version;
-
-/**
- * Returns an object with each of the options you can pass to
- * the render function
- * - the default value
- * - the possible values in an array of objects, each of which
- *   has the properties:
- *   - name: the value
- * @returns {import("../types/state-machine-cat").IAllowedValues}
- */
-export function getAllowedValues() {
-  return options.getAllowedValues();
-}
-
-export default {
-  render,
-  version,
-  getAllowedValues,
-};

package/src/options.mjs

@@ -1,78 +0,0 @@
-// @ts-check
-/** @type {import("../types/state-machine-cat").IAllowedValues} */
-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 }],
-  },
-});
-
-/**
- * Returns the value for the option in the pOption object, and the default
- * for that option in all other cases
- *
- * @param {import("../types/state-machine-cat").IRenderOptions} pOptions - the options as passed in the api `render` function
- * @param {keyof import("../types/state-machine-cat").IRenderOptions} pOptionName - the name of the option
- * @return {string|boolean} value
- */
-function getOptionValue(pOptions, pOptionName) {
-  // eslint-disable-next-line security/detect-object-injection
-  return pOptions?.[pOptionName] ?? ALLOWED_VALUES[pOptionName].default;
-}
-
-/**
- * @returns {import("../types/state-machine-cat").IAllowedValues}
- */
-function getAllowedValues() {
-  return ALLOWED_VALUES;
-}
-
-export default {
-  getAllowedValues,
-  getOptionValue,
-};

package/src/parse/index.mjs

@@ -1,47 +0,0 @@
-// @ts-check
-import Ajv from "ajv";
-import options from "../options.mjs";
-import { parse as parseSmCat } from "./smcat/smcat-parser.mjs";
-import { parse as parseSCXML } from "./scxml/index.mjs";
-import $schema from "./smcat-ast.schema.mjs";
-
-const ajv = new Ajv();
-
-/**
- * @param {typeof $schema} pSchema
- * @param {any} pObject
- * @throws {Error}
- */
-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`
-    );
-  }
-}
-
-export default {
-  /**
-   * @param {string|import("../../types/state-machine-cat").IStateMachine} pScript
-   * @param {import("../../types/state-machine-cat").IRenderOptions} pOptions
-   * @returns {import("../../types/state-machine-cat").IStateMachine}
-   */
-  getAST(pScript, pOptions) {
-    let lReturnValue = pScript;
-
-    if (options.getOptionValue(pOptions, "inputType") === "smcat") {
-      lReturnValue = parseSmCat(pScript);
-    } else if (options.getOptionValue(pOptions, "inputType") === "scxml") {
-      // @ts-expect-error inputType scxml => it's a string
-      lReturnValue = parseSCXML(pScript);
-    } else if (typeof pScript === "string") {
-      // json
-      lReturnValue = JSON.parse(pScript);
-    }
-
-    validateAgainstSchema($schema, lReturnValue);
-
-    // @ts-expect-error by here lReturnValue is bound to be an IStateMachine
-    return lReturnValue;
-  },
-};