data-solectrus 0.2.10

package/admin/i18n/de/translations.json

@@ -0,0 +1,94 @@
+{
+  "Values": "Werte",
+  "Runtime": "Einstellungen",
+  "Poll interval (seconds)": "Intervall (Sekunden)",
+  "Read inputs on tick (snapshot)": "Inputs pro Tick aktiv lesen (Snapshot)",
+  "Snapshot delay (ms)": "Snapshot-Verzögerung (ms)",
+  "Enable sync diagnostics (input timestamp gap)": "Sync-Diagnose aktivieren (Input-Timestamp-Gap)",
+  "Enable sync diagnostics (input timestamp gap) (help)": "Wenn aktiv, aktualisiert der Adapter pro Tick die info.inputTsGap*-States, um Zeitversatz zwischen Inputs sichtbar zu machen.",
+  "Configured values": "Konfigurierte Werte",
+  "Add": "Hinzufügen",
+  "Duplicate": "Duplizieren",
+  "Delete": "Löschen",
+  "Up": "Hoch",
+  "Down": "Runter",
+  "Enabled": "Aktiviert",
+  "Name": "Name",
+  "Target ID": "Ziel-ID",
+  "Mode": "Modus",
+  "Formula": "Formel",
+  "Source": "Quelle",
+  "ioBroker Source State": "ioBroker Quell-State",
+  "Select": "Auswählen",
+  "Inputs": "Eingänge",
+  "Add input": "Eingang hinzufügen",
+  "Key": "Variable",
+  "Datatype": "Datentyp",
+  "Standard": "Standard",
+  "Number": "Zahl",
+  "Boolean": "Boolean",
+  "String": "String",
+  "Mixed": "Mixed",
+  "Role": "Rolle",
+  "Unit": "Einheit",
+  "Folder/Group": "Ordner/Gruppe",
+  "Clamp result": "Ergebnis begrenzen",
+  "Clamp negative to 0": "Ergebnis negativ → 0",
+  "Clamp negative to 0 (hint source)": "Nur Output (ändert den Quell-State nicht).",
+  "Clamp negative to 0 (hint formula)": "Nur Output. Für einzelne Inputs: Input neg→0.",
+  "Clamp negative to 0 (tooltip)": "Begrenzt nur das Ergebnis (Output). Wenn du nur eine Quelle/einen Input begrenzen willst, aktiviere neg→0 direkt am Input.",
+  "Clamp input negative to 0": "Input negativ auf 0",
+  "Min": "Min",
+  "Max": "Max",
+  "Formula expression": "Formel-Ausdruck",
+  "Builder…": "Builder…",
+  "Formula Builder": "Formel-Builder",
+  "Insert building blocks on the left. The editor uses current (unsaved) inputs.": "Bausteine links einfügen. Der Editor nutzt die aktuellen (auch ungespeicherten) Inputs.",
+  "Variables (Inputs)": "Variablen (Inputs)",
+  "No inputs configured yet.": "Noch keine Inputs konfiguriert.",
+  "Operators": "Operatoren",
+  "Functions": "Funktionen",
+  "State functions": "State-Funktionen",
+  "Live values": "Live-Werte",
+  "Refresh": "Aktualisieren",
+  "Loading…": "Lade…",
+  "Result": "Ergebnis",
+  "Refresh preview": "Vorschau aktualisieren",
+  "Preview not available": "Vorschau nicht verfügbar",
+  "Preview timeout": "Vorschau-Timeout",
+  "Adapter not running": "Adapter läuft nicht",
+  "Preview not supported for state functions": "Vorschau für State-Funktionen nicht verfügbar",
+  "Unterminated string": "String nicht geschlossen",
+  "Invalid number": "Ungültige Zahl",
+  "Unexpected character": "Unerwartetes Zeichen",
+  "Expected": "Erwartet",
+  "Unexpected end": "Unerwartetes Ende",
+  "Unknown function": "Unbekannte Funktion",
+  "Unsupported operator": "Nicht unterstützter Operator",
+  "Unexpected token": "Unerwartetes Token",
+  "n/a": "n/v",
+  "Pick a state id and insert s(\"id\")": "State-ID wählen und s(\"id\") einfügen",
+  "Pick a state id and insert v(\"id\")": "State-ID wählen und v(\"id\") einfügen",
+  "Pick a state id and insert jp(\"id\", \"$.value\")": "State-ID wählen und jp(\"id\", \"$.value\") einfügen",
+  "Insert s()": "s() einfügen",
+  "Insert v()": "v() einfügen",
+  "Insert jp()": "jp() einfügen",
+  "Tip: You can still edit the formula as plain text anytime.": "Tipp: Du kannst die Formel jederzeit auch direkt als Text bearbeiten.",
+  "Cancel": "Abbrechen",
+  "Apply": "Übernehmen",
+  "Close": "Schließen",
+  "min": "min",
+  "max": "max",
+  "clamp": "clamp",
+  "IF": "IF",
+  "JSONPath (optional)": "JSONPath (optional)",
+  "e.g. $.apower": "z.B. $.apower",
+  "e.g. pv1 + pv2 + pv3": "z.B. pv1 + pv2 + pv3",
+  "e.g. some.adapter.0.channel.state": "z.B. irgendein.adapter.0.kanal.state",
+  "Selection dialog not available": "Auswahldialog nicht verfügbar",
+  "Select from existing states": "Aus vorhandenen States wählen",
+  "No items configured.": "Keine Werte konfiguriert.",
+  "Select an item on the left or add a new one.": "Links einen Eintrag wählen oder einen neuen hinzufügen.",
+  "Unnamed": "Unbenannt",
+  "Item": "Eintrag"
+}

package/admin/i18n/en/translations.json

@@ -0,0 +1,94 @@
+{
+  "Values": "Values",
+  "Runtime": "Global settings",
+  "Poll interval (seconds)": "Poll interval (seconds)",
+  "Read inputs on tick (snapshot)": "Read inputs on tick (snapshot)",
+  "Snapshot delay (ms)": "Snapshot delay (ms)",
+  "Enable sync diagnostics (input timestamp gap)": "Enable sync diagnostics (input timestamp gap)",
+  "Enable sync diagnostics (input timestamp gap) (help)": "When enabled, the adapter updates info.inputTsGap* states each tick to show input timestamp skew.",
+  "Configured values": "Configured values",
+  "Add": "Add",
+  "Duplicate": "Duplicate",
+  "Delete": "Delete",
+  "Up": "Up",
+  "Down": "Down",
+  "Enabled": "Enabled",
+  "Name": "Name",
+  "Target ID": "Target ID",
+  "Mode": "Mode",
+  "Formula": "Formula",
+  "Source": "Source",
+  "ioBroker Source State": "ioBroker Source State",
+  "Select": "Select",
+  "Inputs": "Inputs",
+  "Add input": "Add input",
+  "Key": "Key",
+  "Datatype": "Datatype",
+  "Standard": "Standard",
+  "Number": "Number",
+  "Boolean": "Boolean",
+  "String": "String",
+  "Mixed": "Mixed",
+  "Role": "Role",
+  "Unit": "Unit",
+  "Folder/Group": "Folder/Group",
+  "Clamp result": "Clamp result",
+  "Clamp negative to 0": "Clamp negative result to 0",
+  "Clamp negative to 0 (hint source)": "Output only (does not change the source state).",
+  "Clamp negative to 0 (hint formula)": "Output only. For single inputs use input neg→0.",
+  "Clamp negative to 0 (tooltip)": "Clamps only the item result (output). If you want to clamp just one source/input, enable neg→0 on that input.",
+  "Min": "Min",
+  "Max": "Max",
+  "Clamp input negative to 0": "Clamp input negative to 0",
+  "Formula expression": "Formula expression",
+  "Builder…": "Builder…",
+  "Formula Builder": "Formula Builder",
+  "Insert building blocks on the left. The editor uses current (unsaved) inputs.": "Insert building blocks on the left. The editor uses current (unsaved) inputs.",
+  "Variables (Inputs)": "Variables (Inputs)",
+  "No inputs configured yet.": "No inputs configured yet.",
+  "Operators": "Operators",
+  "Functions": "Functions",
+  "State functions": "State functions",
+  "Live values": "Live values",
+  "Refresh": "Refresh",
+  "Loading…": "Loading…",
+  "Result": "Result",
+  "Refresh preview": "Refresh preview",
+  "Preview not available": "Preview not available",
+  "Preview timeout": "Preview timeout",
+  "Adapter not running": "Adapter not running",
+  "Preview not supported for state functions": "Preview not supported for state functions",
+  "Unterminated string": "Unterminated string",
+  "Invalid number": "Invalid number",
+  "Unexpected character": "Unexpected character",
+  "Expected": "Expected",
+  "Unexpected end": "Unexpected end",
+  "Unknown function": "Unknown function",
+  "Unsupported operator": "Unsupported operator",
+  "Unexpected token": "Unexpected token",
+  "n/a": "n/a",
+  "Pick a state id and insert s(\"id\")": "Pick a state id and insert s(\"id\")",
+  "Pick a state id and insert v(\"id\")": "Pick a state id and insert v(\"id\")",
+  "Pick a state id and insert jp(\"id\", \"$.value\")": "Pick a state id and insert jp(\"id\", \"$.value\")",
+  "Insert s()": "Insert s()",
+  "Insert v()": "Insert v()",
+  "Insert jp()": "Insert jp()",
+  "Tip: You can still edit the formula as plain text anytime.": "Tip: You can still edit the formula as plain text anytime.",
+  "Cancel": "Cancel",
+  "Apply": "Apply",
+  "Close": "Close",
+  "min": "min",
+  "max": "max",
+  "clamp": "clamp",
+  "IF": "IF",
+  "JSONPath (optional)": "JSONPath (optional)",
+  "e.g. $.apower": "e.g. $.apower",
+  "e.g. pv1 + pv2 + pv3": "e.g. pv1 + pv2 + pv3",
+  "e.g. some.adapter.0.channel.state": "e.g. some.adapter.0.channel.state",
+  "Selection dialog not available": "Selection dialog not available",
+  "Select from existing states": "Select from existing states",
+  "No items configured.": "No items configured.",
+  "Select an item on the left or add a new one.": "Select an item on the left or add a new one.",
+  "Unnamed": "Unnamed",
+  "Item": "Item"
+}

package/admin/jsonConfig.json

@@ -0,0 +1,59 @@
+{
+  "i18n": true,
+  "type": "tabs",
+  "items": {
+    "values": {
+      "type": "panel",
+      "label": "Values",
+      "items": {
+        "hint": {
+          "type": "staticText",
+          "text": "Configure values via the Master/Detail editor.",
+          "sm": 12
+        },
+        "items": {
+          "type": "custom",
+          "url": "custom/customComponents.js",
+          "name": "DataSolectrusItems/Components/DataSolectrusItemsEditor",
+          "label": "Configured values",
+          "sm": 12
+        }
+      }
+    },
+    "runtime": {
+      "type": "panel",
+      "label": "Runtime",
+      "items": {
+        "pollIntervalSeconds": {
+          "type": "number",
+          "label": "Poll interval (seconds)",
+          "min": 1,
+          "max": 3600,
+          "default": 5,
+          "sm": 6
+        },
+        "snapshotInputs": {
+          "type": "checkbox",
+          "label": "Read inputs on tick (snapshot)",
+          "default": false,
+          "sm": 12
+        },
+        "snapshotDelayMs": {
+          "type": "number",
+          "label": "Snapshot delay (ms)",
+          "min": 0,
+          "max": 5000,
+          "default": 0,
+          "sm": 6
+        },
+        "enableInputTsGapDiagnostics": {
+          "type": "checkbox",
+          "label": "Enable sync diagnostics (input timestamp gap)",
+          "default": true,
+          "help": "Enable sync diagnostics (input timestamp gap) (help)",
+          "sm": 12
+        }
+      }
+    }
+  }
+}

package/io-package.json

@@ -0,0 +1,39 @@
+{
+  "common": {
+    "name": "data-solectrus",
+    "version": "0.2.10",
+    "title": "Data-SOLECTRUS",
+    "icon": "data-solectrus.png",
+    "extIcon": "https://raw.githubusercontent.com/Felliglanz/data-solectrus/main/admin/data-solectrus.png",
+    "titleLang": {
+      "en": "Data-SOLECTRUS",
+      "de": "Data-SOLECTRUS"
+    },
+    "desc": {
+      "en": "Compute and mirror ioBroker states into adapter-owned states using formulas.",
+      "de": "Berechnet und spiegelt ioBroker-Datenpunkte als adapter-eigene States mittels Formeln."
+    },
+    "platform": "Javascript/Node.js",
+    "mode": "daemon",
+    "compact": true,
+    "messagebox": true,
+    "enabled": true,
+    "adminUI": {
+      "config": "json"
+    },
+    "type": "energy",
+    "connectionType": "none",
+    "dataSource": "poll",
+    "authors": [
+      "Sven"
+    ],
+    "license": "MIT"
+  },
+  "native": {
+    "pollIntervalSeconds": 5,
+    "enableInputTsGapDiagnostics": true,
+    "items": []
+  },
+  "objects": [],
+  "instanceObjects": []
+}

package/lib/formula.js

@@ -0,0 +1,249 @@
+'use strict';
+
+const jsep = require('jsep');
+
+function parseExpression(expr) {
+	return jsep(String(expr));
+}
+
+/**
+ * Normalizes some common non-JS formula syntax into the JS-like operators that `jsep` understands.
+ * - AND/OR/NOT (case-insensitive) -> && / || / !
+ * - single '=' (outside strings) -> '=='
+ *
+ * This is intentionally conservative and only runs outside quoted strings.
+ */
+function normalizeFormulaExpression(expr) {
+	let s = String(expr);
+	if (!s) return s;
+
+	let out = '';
+	let inSingle = false;
+	let inDouble = false;
+	let escaped = false;
+
+	const isWordChar = c => /[A-Za-z0-9_]/.test(c);
+	const at = i => (i >= 0 && i < s.length ? s[i] : '');
+	const matchWordAt = (i, word) => {
+		// assumes already outside quotes
+		const w = String(word);
+		if (s.substr(i, w.length).toUpperCase() !== w.toUpperCase()) return false;
+		const prev = at(i - 1);
+		const next = at(i + w.length);
+		if (prev && isWordChar(prev)) return false;
+		if (next && isWordChar(next)) return false;
+		return true;
+	};
+
+	for (let i = 0; i < s.length; i++) {
+		const ch = s[i];
+
+		if (escaped) {
+			out += ch;
+			escaped = false;
+			continue;
+		}
+		if (ch === '\\') {
+			out += ch;
+			escaped = true;
+			continue;
+		}
+
+		if (!inDouble && ch === "'") {
+			inSingle = !inSingle;
+			out += ch;
+			continue;
+		}
+		if (!inSingle && ch === '"') {
+			inDouble = !inDouble;
+			out += ch;
+			continue;
+		}
+
+		if (inSingle || inDouble) {
+			out += ch;
+			continue;
+		}
+
+		// AND/OR/NOT keywords
+		if (matchWordAt(i, 'AND')) {
+			out += '&&';
+			i += 2;
+			continue;
+		}
+		if (matchWordAt(i, 'OR')) {
+			out += '||';
+			i += 1;
+			continue;
+		}
+		if (matchWordAt(i, 'NOT')) {
+			out += '!';
+			i += 2;
+			continue;
+		}
+
+		// single '=' -> '==' (but keep ==, ===, !=, <=, >=)
+		if (ch === '=') {
+			const prev = at(i - 1);
+			const next = at(i + 1);
+			const prevIsGuard = prev === '=' || prev === '!' || prev === '<' || prev === '>';
+			if (!prevIsGuard && next !== '=') {
+				out += '==';
+				continue;
+			}
+		}
+
+		out += ch;
+	}
+
+	return out;
+}
+
+function analyzeAst(ast, options) {
+	const maxNodes = options && Number.isFinite(options.maxNodes) ? options.maxNodes : 2000;
+	const maxDepth = options && Number.isFinite(options.maxDepth) ? options.maxDepth : 60;
+	let nodes = 0;
+	let depthMax = 0;
+	/** @type {{node:any, depth:number}[]} */
+	const stack = [{ node: ast, depth: 1 }];
+	while (stack.length) {
+		const entry = stack.pop();
+		const node = entry && entry.node;
+		const depth = entry && entry.depth ? entry.depth : 1;
+		if (!node || typeof node !== 'object') continue;
+		nodes++;
+		if (depth > depthMax) depthMax = depth;
+		if (nodes > maxNodes) {
+			throw new Error(`Expression too complex (>${maxNodes} nodes)`);
+		}
+		if (depthMax > maxDepth) {
+			throw new Error(`Expression too deeply nested (>${maxDepth})`);
+		}
+
+		switch (node.type) {
+			case 'BinaryExpression':
+			case 'LogicalExpression':
+				stack.push({ node: node.right, depth: depth + 1 });
+				stack.push({ node: node.left, depth: depth + 1 });
+				break;
+			case 'UnaryExpression':
+				stack.push({ node: node.argument, depth: depth + 1 });
+				break;
+			case 'ConditionalExpression':
+				stack.push({ node: node.alternate, depth: depth + 1 });
+				stack.push({ node: node.consequent, depth: depth + 1 });
+				stack.push({ node: node.test, depth: depth + 1 });
+				break;
+			case 'CallExpression': {
+				const args = Array.isArray(node.arguments) ? node.arguments : [];
+				for (let i = args.length - 1; i >= 0; i--) {
+					stack.push({ node: args[i], depth: depth + 1 });
+				}
+				// callee is an Identifier in allowed expressions; no need to traverse.
+				break;
+			}
+			default:
+				break;
+		}
+	}
+	return { nodes, depth: depthMax };
+}
+
+function evalFormulaAst(ast, vars, funcs) {
+	const functions = funcs || {};
+	const variables = vars || Object.create(null);
+
+	const evalNode = node => {
+		if (!node || typeof node !== 'object') {
+			throw new Error('Invalid expression');
+		}
+
+		switch (node.type) {
+			case 'Literal':
+				return node.value;
+			case 'Identifier':
+				return Object.prototype.hasOwnProperty.call(variables, node.name) ? variables[node.name] : 0;
+			case 'UnaryExpression': {
+				const arg = evalNode(node.argument);
+				switch (node.operator) {
+					case '+':
+						return Number(arg);
+					case '-':
+						return -Number(arg);
+					case '!':
+						return !arg;
+					default:
+						throw new Error(`Operator not allowed: ${node.operator}`);
+				}
+			}
+			case 'BinaryExpression':
+			case 'LogicalExpression': {
+				const left = evalNode(node.left);
+				const right = evalNode(node.right);
+				switch (node.operator) {
+					case '+':
+						return Number(left) + Number(right);
+					case '-':
+						return Number(left) - Number(right);
+					case '*':
+						return Number(left) * Number(right);
+					case '/':
+						return Number(left) / Number(right);
+					case '%':
+						return Number(left) % Number(right);
+					case '&&':
+						return left && right;
+					case '||':
+						return left || right;
+					case '==':
+						// loose equality intentionally supported for compatibility with other formula engines
+						return left == right;
+					case '!=':
+						return left != right;
+					case '===':
+						return left === right;
+					case '!==':
+						return left !== right;
+					case '<':
+						return Number(left) < Number(right);
+					case '<=':
+						return Number(left) <= Number(right);
+					case '>':
+						return Number(left) > Number(right);
+					case '>=':
+						return Number(left) >= Number(right);
+					default:
+						throw new Error(`Operator not allowed: ${node.operator}`);
+				}
+			}
+			case 'ConditionalExpression': {
+				const test = evalNode(node.test);
+				return test ? evalNode(node.consequent) : evalNode(node.alternate);
+			}
+			case 'CallExpression': {
+				if (!node.callee || node.callee.type !== 'Identifier') {
+					throw new Error('Only simple function calls are allowed');
+				}
+				const fnName = node.callee.name;
+				const fn = functions[fnName];
+				if (typeof fn !== 'function') {
+					throw new Error(`Function not allowed: ${fnName}`);
+				}
+				const args = Array.isArray(node.arguments) ? node.arguments.map(evalNode) : [];
+				return fn.apply(null, args);
+			}
+			default:
+				// Blocks MemberExpression, ThisExpression, NewExpression, etc.
+				throw new Error(`Expression type not allowed: ${node.type}`);
+		}
+	};
+
+	return evalNode(ast);
+}
+
+module.exports = {
+	parseExpression,
+	normalizeFormulaExpression,
+	analyzeAst,
+	evalFormulaAst,
+};