@microtronics/studio-cli 0.46.0 → 0.48.0

package/CHANGELOG.md

@@ -1,9 +1,22 @@
 # Changelog
 
-## 0.46.0 (2026-02-04)
+## 0.48.0 (2026-02-10)
 
-### Bug Fixes
+### Features
 
+* **cli:** support multiline statements in DLO precompiler ([b2aef4d](https://bitbucket.org/microtronics-core/vscode-studio/commits/b2aef4d924bdd328d5f8bb90485d02516cd35d3b))
+
+## 0.47.0 (2026-02-06)
+
+### Bug Fixes
+
+* **cli:** add missing 'tar' dev package ([707f755](https://bitbucket.org/microtronics-core/vscode-studio/commits/707f75561af14ff302b8c780e55cd5a156a9187a))
+* **cli:** add missing 'uuid' package ([48c2fec](https://bitbucket.org/microtronics-core/vscode-studio/commits/48c2fec8fa052326706df2b2e2c7a0a9b71ece24))
+
+## 0.46.0 (2026-02-04)
+
+### Bug Fixes
+
 * limit development site name to 50 characters maximum ([6dd6772](https://bitbucket.org/microtronics-core/vscode-studio/commits/6dd6772eb0d0c84ccf3f68b4a3fcbb751a46f7f8)), closes [#bugfix-ready](https://bitbucket.org/microtronics-core/vscode-studio/issues/bugfix-ready)
 
 ## 0.45.0 (2026-02-04)

package/out/dlo/preCompiler.js

@@ -74,6 +74,102 @@ var LogLevel;
 const rxpDDE = /^(.*)(^|\s*)DDE_(state|result|aloha|volatile|setting|command)_/;
 const rxpUplinkRestore = /^(.*)(^|\s*)onUplink(Restore|Apply)_(state|result|aloha|volatile|setting|command)/;
 const rxpUplinkEvent = /^(.*)(^|\s*)onUplinkEvent/;
+// Regex to detect start of function-like statements that may span multiple lines
+const rxpMultilineFuncStart = /(?:^|\s)(?:assert|catch|applog(?:_ok|_warning|_alarm|_debug|_fatal)?|log(?:_debug|_info|_warn|_error)?)\s*\(/;
+const rxpMultilineCallbackStart = /^\s*#callback\s+\w+\s*\(/;
+/**
+ * Count unbalanced parentheses depth in text, respecting string literals.
+ * Returns a positive number if there are more opening than closing parens.
+ */
+function getParenthesisDepth(text) {
+    let depth = 0;
+    let inString = false;
+    let stringChar = '';
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === '\\') {
+                i++;
+                continue;
+            }
+            if (ch === stringChar) {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = true;
+            stringChar = ch;
+            continue;
+        }
+        if (ch === '(') {
+            depth++;
+        }
+        else if (ch === ')') {
+            depth--;
+        }
+    }
+    return depth;
+}
+/**
+ * Check if a line matches any of the multiline-capable replacement patterns.
+ */
+function matchesAnyMultilineCapablePattern(line) {
+    return (rxpCallback.test(line) ||
+        rxpAssertF.test(line) ||
+        rxpAssert.test(line) ||
+        rxpAssert0.test(line) ||
+        rxpCatch.test(line) ||
+        rxpApplog.test(line) ||
+        rxpApplog0.test(line) ||
+        rxpLogBackend.test(line));
+}
+/**
+ * Try to accumulate a multiline statement starting at the given line index.
+ * Returns null if the line is not a multiline statement start, or if the
+ * accumulated joined line doesn't match any replacement pattern.
+ */
+function tryAccumulateMultilineStatement(fileBlob, startIndex, startStripped) {
+    // Check if this line could start a multiline statement
+    const isCandidate = rxpMultilineFuncStart.test(startStripped) || rxpMultilineCallbackStart.test(startStripped);
+    if (!isCandidate) {
+        return null;
+    }
+    // Check if parentheses are unbalanced (indicating continuation on next lines)
+    const depth = getParenthesisDepth(startStripped);
+    if (depth <= 0) {
+        return null;
+    }
+    // Accumulate lines until parentheses are balanced
+    let totalDepth = depth;
+    const originalLines = [fileBlob[startIndex]];
+    const strippedLines = [startStripped];
+    let nextIndex = startIndex + 1;
+    const maxAccumulation = 100; // Safety limit
+    while (totalDepth > 0 && nextIndex < fileBlob.length && nextIndex - startIndex < maxAccumulation) {
+        const nextOriginal = fileBlob[nextIndex];
+        const nextStripped = nextOriginal.split('//', 1)[0];
+        originalLines.push(nextOriginal);
+        strippedLines.push(nextStripped);
+        totalDepth += getParenthesisDepth(nextStripped);
+        nextIndex++;
+    }
+    // If we couldn't balance the parens or only have one line, abort
+    if (originalLines.length <= 1 || totalDepth > 0) {
+        return null;
+    }
+    const joinedOriginal = originalLines.map((l, i) => (i === 0 ? l : l.trim())).join(' ');
+    const joinedStripped = strippedLines.map((l, i) => (i === 0 ? l : l.trim())).join(' ');
+    // Only use multiline if the joined line actually matches a replacement pattern
+    if (!matchesAnyMultilineCapablePattern(joinedStripped)) {
+        return null;
+    }
+    return {
+        joinedOriginal,
+        joinedStripped,
+        extraLineCount: originalLines.length - 1
+    };
+}
 class DloPreCompiler {
     pragmaDynamic = null;
     dloFileSequencer = new fileSequencer_1.DloFileSequencer();
@@ -137,11 +233,24 @@ class DloPreCompiler {
         let outLineNumber = 0;
         // !!!
         // !!! output is always single-line to keep line numbers equal to original source!
+        // !!! multiline statements are joined into a single line, with empty lines emitted
+        // !!! for consumed continuation lines to preserve line number alignment.
         // !!!
         for (let lineNumber = 0; lineNumber < fileBlob.length; lineNumber++) {
             let newLine = fileBlob[lineNumber];
-            const currentLine = newLine.split('//', 1)[0]; // todo dirty solution! strip-off "end of line" comments
+            let currentLine = newLine.split('//', 1)[0]; // todo dirty solution! strip-off "end of line" comments
             let h = null;
+            let consumedExtraLines = 0;
+            // Detect multiline statements: if the current single line doesn't match any
+            // multiline-capable pattern, try accumulating continuation lines.
+            if (!matchesAnyMultilineCapablePattern(currentLine)) {
+                const multiline = tryAccumulateMultilineStatement(fileBlob, lineNumber, currentLine);
+                if (multiline) {
+                    newLine = multiline.joinedOriginal;
+                    currentLine = multiline.joinedStripped;
+                    consumedExtraLines = multiline.extraLineCount;
+                }
+            }
             // #options
             if ((h = rxpOptions.exec(currentLine))) {
                 newLine = '// ' + newLine;
@@ -303,6 +412,12 @@ class DloPreCompiler {
             }
             precompiledData.push(newLine);
             outLineNumber++;
+            // Emit empty lines for consumed multiline continuation lines
+            for (let i = 0; i < consumedExtraLines; i++) {
+                precompiledData.push('');
+                outLineNumber++;
+                lineNumber++;
+            }
         }
         // add undef of file include
         if (baseName !== 'main.dlo') {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@microtronics/studio-cli",
-	"version": "0.46.0",
+	"version": "0.48.0",
 	"description": "Microtronics Studio CLI Tool",
 	"main": "./out/api.js",
 	"typings": "./dist/studio-cli.d.ts",
@@ -25,6 +25,7 @@
 	"author": "Microtronics",
 	"license": "ISC",
 	"dependencies": {
+		"uuid": "^9.0.1",
 		"@gera2ld/tarjs": "^0.3.1",
 		"ajv": "^8.17.1",
 		"ajv-formats": "^3.0.1",
@@ -70,9 +71,9 @@
 		"mocha": "^10.8.2",
 		"mocha-junit-reporter": "^2.2.1",
 		"openapi-typescript": "^7.6.0",
-		"tar": "^7.4.3",
 		"ts-node": "^10.9.2",
-		"typescript": "^5.6.3"
+		"typescript": "^5.6.3",
+		"tar": "^7.5.7"
 	},
 	"mocha": {
 		"require": [