iobroker.statechart 0.2.0 → 0.3.0

package/admin/{style.css → tab.css}

@@ -10,5 +10,3 @@ body,
     width: 100%;
     margin: 0;
 }
-
-/* Add your styles here */

package/admin/tab_m.html

@@ -17,7 +17,7 @@
         <link
             rel="stylesheet"
             type="text/css"
-            href="style.css"
+            href="tab.css"
         />
     </head>
 

package/build/lib/chart-analysis.js

@@ -0,0 +1,367 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chart_analysis_exports = {};
+__export(chart_analysis_exports, {
+  analyzeChart: () => analyzeChart
+});
+module.exports = __toCommonJS(chart_analysis_exports);
+var acorn = __toESM(require("acorn"));
+var walk = __toESM(require("acorn-walk"));
+var import_chart_helpers = require("./chart-helpers");
+var import_chart_model = require("./chart-model");
+var import_chart_structure = require("./chart-structure");
+function evaluateConstant(node) {
+  switch (node.type) {
+    case "Literal":
+      return { value: node.value };
+    case "Identifier":
+      if (node.name === "undefined") {
+        return { value: void 0 };
+      }
+      return node.name === "NaN" || node.name === "Infinity" ? { value: Number(node.name) } : void 0;
+    case "TemplateLiteral":
+      return node.expressions.length ? void 0 : { value: node.quasis[0]?.value.cooked };
+    case "UnaryExpression": {
+      const arg = evaluateConstant(node.argument);
+      if (!arg) {
+        return void 0;
+      }
+      const value = arg.value;
+      const results = {
+        "!": () => !value,
+        "-": () => -value,
+        "+": () => +value
+      };
+      return node.operator in results ? { value: results[node.operator]() } : void 0;
+    }
+    case "LogicalExpression": {
+      const left = evaluateConstant(node.left);
+      if (!left) {
+        return void 0;
+      }
+      if (node.operator === "&&" && !left.value) {
+        return left;
+      }
+      if (node.operator === "||" && left.value) {
+        return left;
+      }
+      if (node.operator === "??" && left.value != null) {
+        return left;
+      }
+      return evaluateConstant(node.right);
+    }
+    case "BinaryExpression": {
+      const left = node.left.type === "PrivateIdentifier" ? void 0 : evaluateConstant(node.left);
+      const right = left && evaluateConstant(node.right);
+      if (!left || !right) {
+        return void 0;
+      }
+      const [a, b] = [left.value, right.value];
+      const results = {
+        "==": () => a == b,
+        "!=": () => a != b,
+        "===": () => a === b,
+        "!==": () => a !== b,
+        "<": () => a < b,
+        "<=": () => a <= b,
+        ">": () => a > b,
+        ">=": () => a >= b,
+        "+": () => a + b,
+        "-": () => a - b,
+        "*": () => a * b,
+        "/": () => a / b,
+        "%": () => a % b
+      };
+      return node.operator in results ? { value: results[node.operator]() } : void 0;
+    }
+    case "ConditionalExpression": {
+      const test = evaluateConstant(node.test);
+      if (!test) {
+        return void 0;
+      }
+      return evaluateConstant(test.value ? node.consequent : node.alternate);
+    }
+    default:
+      return void 0;
+  }
+}
+function evaluateCondition(code) {
+  try {
+    const ast = acorn.parseExpressionAt(code, 0, { ecmaVersion: "latest" });
+    return code.substring(ast.end).trim() ? void 0 : evaluateConstant(ast);
+  } catch {
+    return void 0;
+  }
+}
+class Usage {
+  read = /* @__PURE__ */ new Set();
+  written = /* @__PURE__ */ new Set();
+  /**
+   * Adds the variables used by a condition or action
+   *
+   * @param code The code, ignored if it has syntax errors
+   * @param kind Condition (expression) or action (statements)
+   */
+  add(code, kind) {
+    if (!code?.trim()) {
+      return;
+    }
+    let ast;
+    try {
+      ast = kind === "statements" ? acorn.parse(code, { ecmaVersion: "latest", sourceType: "script" }) : acorn.parseExpressionAt(code, 0, { ecmaVersion: "latest" });
+    } catch {
+      return;
+    }
+    const declared = /* @__PURE__ */ new Set();
+    const references = [];
+    walk.fullAncestor(ast, (node, _state, ancestors, type) => {
+      if (node.type !== "Identifier") {
+        return;
+      }
+      const parent = ancestors[ancestors.length - 2];
+      if (type === "VariablePattern") {
+        if (parent?.type === "AssignmentExpression" && parent.left === node) {
+          references.push({ name: node.name, write: true });
+        } else {
+          declared.add(node.name);
+        }
+      } else {
+        references.push({ name: node.name, write: parent?.type === "UpdateExpression" });
+      }
+    });
+    walk.simple(ast, {
+      CallExpression: (node) => {
+        const arg = node.arguments[0];
+        if (node.callee.type === "Identifier" && import_chart_helpers.CHANGE_HELPERS.has(node.callee.name) && arg?.type === "Literal" && typeof arg.value === "string") {
+          this.read.add(arg.value);
+        }
+      }
+    });
+    for (const { name, write } of references) {
+      if (!declared.has(name)) {
+        (write ? this.written : this.read).add(name);
+      }
+    }
+  }
+}
+function analyzeChart(chart) {
+  const structure = new import_chart_structure.ChartStructure(chart);
+  const findings = [];
+  const add = (kind, id, severity, key, args = []) => {
+    findings.push({ kind, id, severity, key, args });
+  };
+  const stateName = (id) => structure.statesById.get(id)?.name ?? id;
+  const usage = new Usage();
+  const validBySource = /* @__PURE__ */ new Map();
+  for (const state of chart.states) {
+    for (const transition of structure.getTransitions(state.id)) {
+      let label;
+      try {
+        label = (0, import_chart_model.parseTransitionLabel)(transition.label);
+      } catch {
+        continue;
+      }
+      usage.add(label.condition, "expression");
+      usage.add(label.temporal?.condition, "expression");
+      usage.add(label.action, "statements");
+      for (const event of [label.event, label.temporal?.event]) {
+        if (event) {
+          usage.read.add(event);
+        }
+      }
+      if (!structure.statesById.has(transition.target) || structure.getCrossedParallel(transition) !== void 0) {
+        continue;
+      }
+      const condition = label.condition ? evaluateCondition(label.condition) : { value: true };
+      const temporalCondition = label.temporal?.condition && evaluateCondition(label.temporal.condition);
+      if (condition && !condition.value) {
+        add(
+          "transition",
+          transition.id,
+          "warning",
+          "The condition is never true, the transition is never taken"
+        );
+        continue;
+      }
+      if (temporalCondition && !temporalCondition.value) {
+        add(
+          "transition",
+          transition.id,
+          "warning",
+          "The condition is never true, the transition is never taken"
+        );
+        continue;
+      }
+      if (label.condition && condition) {
+        add("transition", transition.id, "info", "The condition is always true");
+      }
+      const valid = { transition, label, alwaysTrue: !!condition };
+      validBySource.set(state.id, [...validBySource.get(state.id) || [], valid]);
+    }
+  }
+  findUnreachable(structure, validBySource, add);
+  findShadowed(structure, validBySource, add, stateName);
+  for (const state of chart.states) {
+    if (structure.getChildren(state.id).length || state.during?.trim()) {
+      continue;
+    }
+    if (structure.getPath(state.id).every((id) => !validBySource.get(id)?.length)) {
+      add(
+        "state",
+        state.id,
+        "info",
+        "The chart stays in this state: neither it nor a state containing it has an outgoing transition"
+      );
+    }
+  }
+  for (const state of chart.states) {
+    usage.add(state.entry, "statements");
+    usage.add(state.during, "statements");
+    usage.add(state.exit, "statements");
+  }
+  for (const fn of chart.functions || []) {
+    usage.add(fn.code, "statements");
+  }
+  for (const symbol of chart.symbols) {
+    const { read, written } = { read: usage.read.has(symbol.name), written: usage.written.has(symbol.name) };
+    if (symbol.scope === "input" && !read && !written) {
+      add("symbol", symbol.name, "info", "The input is not used, it only wakes up the chart");
+    } else if (symbol.scope === "output" && !written) {
+      add("symbol", symbol.name, "warning", "The output is never written");
+    } else if (symbol.scope === "local" && !read) {
+      add(
+        "symbol",
+        symbol.name,
+        "info",
+        written ? "The variable is written but never read" : "The variable is not used"
+      );
+    }
+  }
+  return findings;
+}
+function findUnreachable(structure, validBySource, add) {
+  const reachable = /* @__PURE__ */ new Set();
+  const enterDefault = (id) => {
+    if (reachable.has(id)) {
+      return;
+    }
+    reachable.add(id);
+    const children = structure.getChildren(id);
+    const initial2 = structure.getInitialChild(id);
+    for (const child of structure.isParallel(id) ? children : children.filter((c) => c.id === initial2)) {
+      enterDefault(child.id);
+    }
+  };
+  const enter = (target) => {
+    for (const id of structure.getPath(target)) {
+      reachable.add(id);
+      const parent = structure.statesById.get(id)?.parent || null;
+      if (structure.isParallel(parent)) {
+        for (const sibling of structure.getChildren(parent)) {
+          if (sibling.id !== id) {
+            enterDefault(sibling.id);
+          }
+        }
+      }
+    }
+    reachable.delete(target);
+    enterDefault(target);
+  };
+  const topLevel = structure.getChildren(null);
+  const initial = structure.getInitialChild(null);
+  for (const state of structure.isParallel(null) ? topLevel : topLevel.filter((s) => s.id === initial)) {
+    enterDefault(state.id);
+  }
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const [source, transitions] of validBySource) {
+      if (!reachable.has(source)) {
+        continue;
+      }
+      for (const { transition } of transitions) {
+        const before = reachable.size;
+        enter(transition.target);
+        changed ||= reachable.size !== before;
+      }
+    }
+  }
+  for (const state of structure.chart.states) {
+    const parent = state.parent && structure.statesById.has(state.parent) ? state.parent : null;
+    if (!reachable.has(state.id) && (!parent || reachable.has(parent))) {
+      add("state", state.id, "warning", "The state never becomes active: no transition leads to it");
+    }
+  }
+}
+function findShadowed(structure, validBySource, add, stateName) {
+  for (const transitions of validBySource.values()) {
+    let always;
+    const byEvent = /* @__PURE__ */ new Map();
+    const byTrigger = /* @__PURE__ */ new Map();
+    const outer = transitions.filter((t) => !structure.getTransitionKind(t.transition).inner);
+    const inner = transitions.filter((t) => structure.getTransitionKind(t.transition).inner);
+    for (const { transition, label, alwaysTrue } of [...outer, ...inner]) {
+      const trigger = JSON.stringify([label.event, label.temporal, label.condition?.replace(/\s+/g, "")]);
+      const before = always ?? (label.event ? byEvent.get(label.event) : void 0);
+      if (before) {
+        add(
+          "transition",
+          transition.id,
+          "warning",
+          'Never taken: the transition to "%s" before it is always valid',
+          [stateName(before.target)]
+        );
+        continue;
+      }
+      const same = byTrigger.get(trigger);
+      if (same) {
+        add(
+          "transition",
+          transition.id,
+          "warning",
+          'Never taken: the transition to "%s" before it has the same event and condition',
+          [stateName(same.target)]
+        );
+        continue;
+      }
+      byTrigger.set(trigger, transition);
+      if (alwaysTrue && !label.temporal) {
+        if (label.event) {
+          byEvent.set(label.event, transition);
+        } else {
+          always = transition;
+        }
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeChart
+});
+//# sourceMappingURL=chart-analysis.js.map

package/build/lib/chart-analysis.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/chart-analysis.ts"],
+  "sourcesContent": ["/*\n * Static analysis of a chart: finds logical problems without running it, e.g. states which can never become\n * active, transitions which are never taken or variables which are not used. Syntax errors and unknown names are\n * found by the validation, the analysis ignores the code and labels with errors.\n */\n\nimport * as acorn from \"acorn\";\nimport * as walk from \"acorn-walk\";\nimport { CHANGE_HELPERS } from \"./chart-helpers\";\nimport { parseTransitionLabel } from \"./chart-model\";\nimport type { Chart, ChartTransition, TransitionLabel } from \"./chart-model\";\nimport { ChartStructure } from \"./chart-structure\";\n\nexport type Severity = \"error\" | \"warning\" | \"info\";\n\n/** A problem of the chart as a whole, not at a position in a text */\nexport interface Finding {\n    /** What the problem is about */\n    kind: \"state\" | \"transition\" | \"symbol\";\n    /** ID of the state or transition, name of the variable */\n    id: string;\n    /** How severe the problem is */\n    severity: Severity;\n    /** English message with %s placeholders, used to translate it */\n    key: string;\n    /** Values for the %s placeholders of the message */\n    args: string[];\n}\n\n/** A transition the runtime executes, with its parsed label */\ninterface ValidTransition {\n    transition: ChartTransition;\n    label: TransitionLabel;\n    /** The condition is always true or there is none */\n    alwaysTrue: boolean;\n}\n\ntype Constant = { value: unknown } | undefined;\n\n/**\n * Evaluates an expression which only consists of literals and operators, e.g. `true` or `1 > 2`\n *\n * @param node The expression\n * @returns undefined if the value depends on variables or function calls\n */\nfunction evaluateConstant(node: acorn.AnyNode): Constant {\n    switch (node.type) {\n        case \"Literal\":\n            return { value: node.value };\n        case \"Identifier\":\n            if (node.name === \"undefined\") {\n                return { value: undefined };\n            }\n            return node.name === \"NaN\" || node.name === \"Infinity\" ? { value: Number(node.name) } : undefined;\n        case \"TemplateLiteral\":\n            return node.expressions.length ? undefined : { value: node.quasis[0]?.value.cooked };\n        case \"UnaryExpression\": {\n            const arg = evaluateConstant(node.argument);\n            if (!arg) {\n                return undefined;\n            }\n            const value = arg.value as any;\n            const results: Record<string, () => unknown> = {\n                \"!\": () => !value,\n                \"-\": () => -value,\n                \"+\": () => +value,\n            };\n            return node.operator in results ? { value: results[node.operator]() } : undefined;\n        }\n        case \"LogicalExpression\": {\n            const left = evaluateConstant(node.left);\n            if (!left) {\n                return undefined;\n            }\n            // a constant left side may decide the result on its own\n            if (node.operator === \"&&\" && !left.value) {\n                return left;\n            }\n            if (node.operator === \"||\" && left.value) {\n                return left;\n            }\n            if (node.operator === \"??\" && left.value != null) {\n                return left;\n            }\n            return evaluateConstant(node.right);\n        }\n        case \"BinaryExpression\": {\n            const left = node.left.type === \"PrivateIdentifier\" ? undefined : evaluateConstant(node.left);\n            const right = left && evaluateConstant(node.right);\n            if (!left || !right) {\n                return undefined;\n            }\n            const [a, b] = [left.value as any, right.value as any];\n            const results: Record<string, () => unknown> = {\n                \"==\": () => a == b,\n                \"!=\": () => a != b,\n                \"===\": () => a === b,\n                \"!==\": () => a !== b,\n                \"<\": () => a < b,\n                \"<=\": () => a <= b,\n                \">\": () => a > b,\n                \">=\": () => a >= b,\n                \"+\": () => a + b,\n                \"-\": () => a - b,\n                \"*\": () => a * b,\n                \"/\": () => a / b,\n                \"%\": () => a % b,\n            };\n            return node.operator in results ? { value: results[node.operator]() } : undefined;\n        }\n        case \"ConditionalExpression\": {\n            const test = evaluateConstant(node.test);\n            if (!test) {\n                return undefined;\n            }\n            return evaluateConstant(test.value ? node.consequent : node.alternate);\n        }\n        default:\n            return undefined;\n    }\n}\n\n/**\n * @param code A condition\n * @returns its value if it does not depend on anything, undefined otherwise or if it has syntax errors\n */\nfunction evaluateCondition(code: string): Constant {\n    try {\n        const ast = acorn.parseExpressionAt(code, 0, { ecmaVersion: \"latest\" });\n        return code.substring(ast.end).trim() ? undefined : evaluateConstant(ast);\n    } catch {\n        return undefined;\n    }\n}\n\n/** Which variables are read and written */\nclass Usage {\n    readonly read = new Set<string>();\n    readonly written = new Set<string>();\n\n    /**\n     * Adds the variables used by a condition or action\n     *\n     * @param code The code, ignored if it has syntax errors\n     * @param kind Condition (expression) or action (statements)\n     */\n    add(code: string | undefined, kind: \"expression\" | \"statements\"): void {\n        if (!code?.trim()) {\n            return;\n        }\n        let ast;\n        try {\n            ast =\n                kind === \"statements\"\n                    ? acorn.parse(code, { ecmaVersion: \"latest\", sourceType: \"script\" })\n                    : acorn.parseExpressionAt(code, 0, { ecmaVersion: \"latest\" });\n        } catch {\n            return;\n        }\n        // names declared in the code itself (let, const, function parameters, ...) hide the variables\n        const declared = new Set<string>();\n        const references: { name: string; write: boolean }[] = [];\n        walk.fullAncestor(ast, (node, _state, ancestors, type) => {\n            if (node.type !== \"Identifier\") {\n                return;\n            }\n            const parent = ancestors[ancestors.length - 2] as acorn.AnyNode | undefined;\n            if (type === \"VariablePattern\") {\n                // acorn-walk uses \"VariablePattern\" for declarations and for assignment targets\n                if (parent?.type === \"AssignmentExpression\" && parent.left === node) {\n                    references.push({ name: node.name, write: true });\n                } else {\n                    declared.add(node.name);\n                }\n            } else {\n                // count++ only changes the variable, its value is not used\n                references.push({ name: node.name, write: parent?.type === \"UpdateExpression\" });\n            }\n        });\n        walk.simple(ast, {\n            CallExpression: node => {\n                const arg = node.arguments[0];\n                // the variable of hasChanged(\"name\")\n                if (\n                    node.callee.type === \"Identifier\" &&\n                    CHANGE_HELPERS.has(node.callee.name) &&\n                    arg?.type === \"Literal\" &&\n                    typeof arg.value === \"string\"\n                ) {\n                    this.read.add(arg.value);\n                }\n            },\n        });\n        for (const { name, write } of references) {\n            if (!declared.has(name)) {\n                (write ? this.written : this.read).add(name);\n            }\n        }\n    }\n}\n\n/**\n * Finds the logical problems of a chart\n *\n * @param chart The chart\n */\nexport function analyzeChart(chart: Chart): Finding[] {\n    const structure = new ChartStructure(chart);\n    const findings: Finding[] = [];\n    const add = (kind: Finding[\"kind\"], id: string, severity: Severity, key: string, args: string[] = []): void => {\n        findings.push({ kind, id, severity, key, args });\n    };\n    const stateName = (id: string): string => structure.statesById.get(id)?.name ?? id;\n\n    // the transitions the runtime executes, by source\n    const usage = new Usage();\n    const validBySource = new Map<string, ValidTransition[]>();\n    for (const state of chart.states) {\n        for (const transition of structure.getTransitions(state.id)) {\n            let label;\n            try {\n                label = parseTransitionLabel(transition.label);\n            } catch {\n                continue;\n            }\n            usage.add(label.condition, \"expression\");\n            usage.add(label.temporal?.condition, \"expression\");\n            usage.add(label.action, \"statements\");\n            for (const event of [label.event, label.temporal?.event]) {\n                if (event) {\n                    usage.read.add(event);\n                }\n            }\n            if (\n                !structure.statesById.has(transition.target) ||\n                structure.getCrossedParallel(transition) !== undefined\n            ) {\n                continue;\n            }\n            const condition = label.condition ? evaluateCondition(label.condition) : { value: true };\n            const temporalCondition = label.temporal?.condition && evaluateCondition(label.temporal.condition);\n            if (condition && !condition.value) {\n                add(\n                    \"transition\",\n                    transition.id,\n                    \"warning\",\n                    \"The condition is never true, the transition is never taken\",\n                );\n                continue;\n            }\n            if (temporalCondition && !temporalCondition.value) {\n                add(\n                    \"transition\",\n                    transition.id,\n                    \"warning\",\n                    \"The condition is never true, the transition is never taken\",\n                );\n                continue;\n            }\n            if (label.condition && condition) {\n                add(\"transition\", transition.id, \"info\", \"The condition is always true\");\n            }\n            const valid = { transition, label, alwaysTrue: !!condition };\n            validBySource.set(state.id, [...(validBySource.get(state.id) || []), valid]);\n        }\n    }\n\n    findUnreachable(structure, validBySource, add);\n    findShadowed(structure, validBySource, add, stateName);\n\n    // leaf states which are never left\n    for (const state of chart.states) {\n        if (structure.getChildren(state.id).length || state.during?.trim()) {\n            // a state with a during action may do its work as long as it is active\n            continue;\n        }\n        if (structure.getPath(state.id).every(id => !validBySource.get(id)?.length)) {\n            add(\n                \"state\",\n                state.id,\n                \"info\",\n                \"The chart stays in this state: neither it nor a state containing it has an outgoing transition\",\n            );\n        }\n    }\n\n    // variables which are not used\n    for (const state of chart.states) {\n        usage.add(state.entry, \"statements\");\n        usage.add(state.during, \"statements\");\n        usage.add(state.exit, \"statements\");\n    }\n    for (const fn of chart.functions || []) {\n        usage.add(fn.code, \"statements\");\n    }\n    for (const symbol of chart.symbols) {\n        const { read, written } = { read: usage.read.has(symbol.name), written: usage.written.has(symbol.name) };\n        if (symbol.scope === \"input\" && !read && !written) {\n            add(\"symbol\", symbol.name, \"info\", \"The input is not used, it only wakes up the chart\");\n        } else if (symbol.scope === \"output\" && !written) {\n            add(\"symbol\", symbol.name, \"warning\", \"The output is never written\");\n        } else if (symbol.scope === \"local\" && !read) {\n            add(\n                \"symbol\",\n                symbol.name,\n                \"info\",\n                written ? \"The variable is written but never read\" : \"The variable is not used\",\n            );\n        }\n    }\n    return findings;\n}\n\n/**\n * Finds the states which can never become active: the topmost ones, their sub states are not reported\n *\n * @param structure The structure of the chart\n * @param validBySource The transitions the runtime executes, by source\n * @param add Adds a finding\n */\nfunction findUnreachable(\n    structure: ChartStructure,\n    validBySource: Map<string, ValidTransition[]>,\n    add: (kind: Finding[\"kind\"], id: string, severity: Severity, key: string) => void,\n): void {\n    const reachable = new Set<string>();\n    // enters a state like the runtime: with its initial sub state, or all of them if they are parallel\n    const enterDefault = (id: string): void => {\n        if (reachable.has(id)) {\n            return;\n        }\n        reachable.add(id);\n        const children = structure.getChildren(id);\n        const initial = structure.getInitialChild(id);\n        for (const child of structure.isParallel(id) ? children : children.filter(c => c.id === initial)) {\n            enterDefault(child.id);\n        }\n    };\n    // enters the target of a transition with its parents, and their parallel siblings\n    const enter = (target: string): void => {\n        for (const id of structure.getPath(target)) {\n            reachable.add(id);\n            const parent = structure.statesById.get(id)?.parent || null;\n            if (structure.isParallel(parent)) {\n                for (const sibling of structure.getChildren(parent)) {\n                    if (sibling.id !== id) {\n                        enterDefault(sibling.id);\n                    }\n                }\n            }\n        }\n        // the history is only set by sub states which were active before, so they are reachable anyway\n        reachable.delete(target);\n        enterDefault(target);\n    };\n\n    const topLevel = structure.getChildren(null);\n    const initial = structure.getInitialChild(null);\n    for (const state of structure.isParallel(null) ? topLevel : topLevel.filter(s => s.id === initial)) {\n        enterDefault(state.id);\n    }\n    for (let changed = true; changed;) {\n        changed = false;\n        for (const [source, transitions] of validBySource) {\n            if (!reachable.has(source)) {\n                continue;\n            }\n            for (const { transition } of transitions) {\n                const before = reachable.size;\n                enter(transition.target);\n                changed ||= reachable.size !== before;\n            }\n        }\n    }\n\n    for (const state of structure.chart.states) {\n        const parent = state.parent && structure.statesById.has(state.parent) ? state.parent : null;\n        if (!reachable.has(state.id) && (!parent || reachable.has(parent))) {\n            add(\"state\", state.id, \"warning\", \"The state never becomes active: no transition leads to it\");\n        }\n    }\n}\n\n/**\n * Finds the transitions which are never taken because one before them is always valid: it has no condition (or one\n * which is always true) and no temporal logic, and no event or the same event. Like in the runtime, the transitions\n * leaving a state are checked before its inner transitions.\n *\n * @param structure The structure of the chart\n * @param validBySource The transitions the runtime executes, by source\n * @param add Adds a finding\n * @param stateName Returns the name of a state\n */\nfunction findShadowed(\n    structure: ChartStructure,\n    validBySource: Map<string, ValidTransition[]>,\n    add: (kind: Finding[\"kind\"], id: string, severity: Severity, key: string, args: string[]) => void,\n    stateName: (id: string) => string,\n): void {\n    for (const transitions of validBySource.values()) {\n        /** the transition which is always valid, for all wakeups */\n        let always: ChartTransition | undefined;\n        /** the transitions which are always valid, by event */\n        const byEvent = new Map<string, ChartTransition>();\n        /** the transitions by event, temporal logic and condition */\n        const byTrigger = new Map<string, ChartTransition>();\n        const outer = transitions.filter(t => !structure.getTransitionKind(t.transition).inner);\n        const inner = transitions.filter(t => structure.getTransitionKind(t.transition).inner);\n        for (const { transition, label, alwaysTrue } of [...outer, ...inner]) {\n            const trigger = JSON.stringify([label.event, label.temporal, label.condition?.replace(/\\s+/g, \"\")]);\n            const before = always ?? (label.event ? byEvent.get(label.event) : undefined);\n            if (before) {\n                add(\n                    \"transition\",\n                    transition.id,\n                    \"warning\",\n                    'Never taken: the transition to \"%s\" before it is always valid',\n                    [stateName(before.target)],\n                );\n                continue;\n            }\n            const same = byTrigger.get(trigger);\n            if (same) {\n                add(\n                    \"transition\",\n                    transition.id,\n                    \"warning\",\n                    'Never taken: the transition to \"%s\" before it has the same event and condition',\n                    [stateName(same.target)],\n                );\n                continue;\n            }\n            byTrigger.set(trigger, transition);\n            if (alwaysTrue && !label.temporal) {\n                if (label.event) {\n                    byEvent.set(label.event, transition);\n                } else {\n                    always = transition;\n                }\n            }\n        }\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["initial"]
+}

package/build/lib/chart-codegen.js

@@ -99,11 +99,11 @@ function generateChartCode(chart, chartId) {
         symbol.debounceMs ? `after ${symbol.debounceMs} ms without updates` : ""
       ].filter(Boolean).join(", ");
       lines.push(
-        `let ${symbol.name} = getState(${JSON.stringify(symbol.stateId)}); // input, wakes up the chart ${trigger}`
+        `let ${symbol.name} = getState(${JSON.stringify(symbol.stateId)})?.val; // input, wakes up the chart ${trigger}`
       );
     } else {
       lines.push(
-        `let ${symbol.name} = getState(${JSON.stringify(symbol.stateId)}); // output, see writeChangedOutputs()`
+        `let ${symbol.name} = getState(${JSON.stringify(symbol.stateId)})?.val; // output, see writeChangedOutputs()`
       );
     }
   }
@@ -126,7 +126,7 @@ function generateChartCode(chart, chartId) {
     `${INDENT}id: ${JSON.stringify(`chart_${chartId}`)},`
   );
   const transitionConfig = (transition, kind, label, level) => {
-    const parts = [`target: ${JSON.stringify(`#${transition.target}`)}`];
+    const parts = [`target: ${JSON.stringify(`#${structure.getTargetId(transition)}`)}`];
     if (kind.reenter) {
       parts.push("reenter: true");
     }
@@ -176,17 +176,30 @@ function generateChartCode(chart, chartId) {
     }
     const children = structure.getChildren(state.id);
     if (children.length) {
-      lines.push(`${i2}initial: ${JSON.stringify(structure.getInitialChild(state.id))},`, `${i2}states: {`);
+      lines.push(
+        structure.isParallel(state.id) ? `${i2}type: "parallel", // all sub states are active, entered in their execution order` : `${i2}initial: ${JSON.stringify(structure.getInitialChild(state.id))},`,
+        `${i2}states: {`
+      );
       for (const child of children) {
         buildState(child, level + 2);
       }
+      if (structure.hasHistory(state.id)) {
+        const id = `${state.id}${import_chart_structure.HISTORY_SUFFIX}`;
+        lines.push(
+          `${i3}// history junction: returns to the last active sub state, the first time to the initial one`,
+          `${i3}${JSON.stringify(import_chart_structure.HISTORY_SUFFIX)}: { id: ${JSON.stringify(id)}, type: "history" },`
+        );
+      }
       lines.push(`${i2}},`);
     }
     lines.push(`${i1}},`);
   };
   const topLevel = structure.getChildren(null);
   if (topLevel.length) {
-    lines.push(`${INDENT}initial: ${JSON.stringify(structure.getInitialChild(null))},`, `${INDENT}states: {`);
+    lines.push(
+      structure.isParallel(null) ? `${INDENT}type: "parallel", // all top level states are active, entered in their execution order` : `${INDENT}initial: ${JSON.stringify(structure.getInitialChild(null))},`,
+      `${INDENT}states: {`
+    );
     for (const state of topLevel) {
       buildState(state, 2);
     }
@@ -206,6 +219,29 @@ function generateChartCode(chart, chartId) {
 ${INDENT.repeat(level + 1)}${prefix}process_${identifier(s.id)}(input);
 ${INDENT.repeat(level)}}`
   );
+  const processChildren = (parent, children) => {
+    if (!structure.isParallel(parent)) {
+      return [...callActive(children, 1, "return "), `${INDENT}return false;`];
+    }
+    const lines2 = [
+      `${INDENT}// all sub states are active (parallel), they are processed in their execution order.`,
+      `${INDENT}// A transition in one of them does not stop the others, unless it left this state.`,
+      ...parent ? [`${INDENT}const entries = entryCount(${JSON.stringify(parent)});`] : [],
+      `${INDENT}let taken = false;`
+    ];
+    children.forEach((child, i) => {
+      if (i && parent) {
+        lines2.push(
+          `${INDENT}if (!isActive(${JSON.stringify(parent)}) || entryCount(${JSON.stringify(parent)}) !== entries) {`,
+          `${INDENT}${INDENT}return true; // left (and maybe entered again) by the transition`,
+          `${INDENT}}`
+        );
+      }
+      lines2.push(`${INDENT}taken = process_${identifier(child.id)}(input) || taken;`);
+    });
+    lines2.push(`${INDENT}return taken;`);
+    return lines2;
+  };
   lines.push(
     "// ---------- Wakeup ----------",
     "",
@@ -235,18 +271,43 @@ ${INDENT.repeat(level)}}`
     " * @returns {boolean} true if a transition was taken",
     " */",
     "function step(input) {",
-    ...callActive(topLevel, 1, "return "),
-    `${INDENT}return false;`,
+    ...processChildren(null, topLevel),
     "}",
     ""
   );
+  const temporalCheck = (transition, temporal) => {
+    const id = JSON.stringify(transition.id);
+    const source = JSON.stringify(transition.source);
+    if (temporal.event !== void 0) {
+      const event = JSON.stringify(temporal.event);
+      const count = `inputCount(${source}, ${event})`;
+      const checks = {
+        after: `${count} >= ${temporal.count}`,
+        before: `${count} < ${temporal.count}`,
+        at: `${count} === ${temporal.count}`,
+        every: `${count} % ${temporal.count} === 0`
+      };
+      return `input === ${event} && ${checks[temporal.operator]}`;
+    }
+    if (temporal.condition !== void 0) {
+      return `trueFor(${id}) >= ${temporal.ms}`;
+    }
+    switch (temporal.operator) {
+      case "after":
+        return `timeInState(${source}) >= ${temporal.ms}`;
+      case "before":
+        return `timeInState(${source}) < ${temporal.ms}`;
+      default:
+        return `timerFired(${id})`;
+    }
+  };
   const check = (transition, label) => {
     const conditions = [];
     if (label.event) {
       conditions.push(`input === ${JSON.stringify(label.event)}`);
     }
-    if (label.afterMs !== void 0) {
-      conditions.push(`elapsed(${JSON.stringify(transition.source)}) >= ${label.afterMs}`);
+    if (label.temporal) {
+      conditions.push(temporalCheck(transition, label.temporal));
     }
     if (label.condition) {
       conditions.push(`(${label.condition})`);
@@ -292,9 +353,8 @@ ${indent(dedent(state.during), 2)}
 ${INDENT}}` : `${INDENT}// none`,
       `${INDENT}// 3. inner transitions (to own sub states, the state stays active)`,
       ...inner.length ? inner : [`${INDENT}// none`],
-      `${INDENT}// 4. active sub state`,
-      ...children.length ? callActive(children, 1, "return ") : [`${INDENT}// none`],
-      `${INDENT}return false;`,
+      `${INDENT}// 4. ${structure.isParallel(state.id) && children.length ? "all sub states" : "active sub state"}`,
+      ...children.length ? processChildren(state.id, children) : [`${INDENT}// none`, `${INDENT}return false;`],
       "}",
       ""
     );
@@ -313,10 +373,17 @@ ${INDENT}}`
     "}",
     "",
     "// Provided by the adapter:",
-    "// getState(id)        current value of an ioBroker state",
     "// isActive(stateId)   true if the state of the chart is active",
-    "// elapsed(stateId)    milliseconds since the state was entered; when it reaches the delay of an",
-    "//                     after(...) of the state, a timer calls wakeup(null)",
+    "// entryCount(stateId) how often the state was entered",
+    "// timeInState(stateId) milliseconds since the state was entered; when it reaches the delay of an",
+    "//                     after(n, unit) or at(n, unit) of the state, a timer calls wakeup(null)",
+    '// timerFired(id)      true in the wakeup(null) of the timer of at(n, unit), every(n, unit) or at("sunset")',
+    '//                     of the transition; at("sunset", offset) and at("22:30") have a timer for every day',
+    "// inputCount(stateId, input)",
+    "//                     the wakeups by the input since the state was entered, for e.g. after(3, button)",
+    "// trueFor(id)         milliseconds the condition of after(n, unit, condition) of the transition has been true,",
+    "//                     checked at the start and at the end of every wakeup; a timer calls wakeup(null) when",
+    "//                     it reaches the delay",
     "// At the start of each wakeup, the adapter stores the values of the variables used in hasChanged(),",
     "// hasChangedFrom() and hasChangedTo(), these compare them with the values of the previous wakeup.",
     "//",