nodalis-compiler 1.0.18 → 1.0.20

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.0.20] 2026-03-03
+- Changed IEC parser to interpret Function Blocks that are actually standard functions to a formal function call.
+- Fixed nodejs/jint compiles to put executables in a bin folder.
+
 ## [1.0.17] 2026-02-25
 - Added support for compilation of multiple ST files as a single project.
 - Added support for formal parameters.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodalis-compiler",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "Compiles IEC-61131-3/10 languages into code that can be used as a PLC on multiple platforms.",
   "icon": "nodalis.png",
   "main": "src/nodalis.js",

package/src/compilers/ArduinoCompiler.js

@@ -255,7 +255,7 @@ void loop() {
         fs.cpSync(path.join(supportDir, 'gpio.cpp'), path.join(outputPath, 'gpio.cpp'), { force: true });
         fs.cpSync(path.join(supportDir, 'json.hpp'), path.join(outputPath, 'json.hpp'), { force: true });
 
-        if (outputType === 'executable') {
+        if (this.isExecutableOutput()) {
             const arduinoCli = compilerConfig.arduino_cli || compilerConfig.arduinoCli || 'arduino-cli';
             const arduinoFqbn = this.resolveArduinoFqbn(target, compilerConfig);
             if (!arduinoFqbn) {
@@ -266,7 +266,7 @@ void loop() {
             this.ensureArduinoCoreInstalled(arduinoCli, arduinoFqbn);
 
             const buildDir = path.join(outputPath, 'build');
-            const binDir = path.join(outputPath, 'bin');
+            const binDir = this.getExecutableOutputPath();
             fs.mkdirSync(buildDir, { recursive: true });
             fs.mkdirSync(binDir, { recursive: true });
             const arduinoCompileCmd = `${arduinoCli} compile --fqbn "${arduinoFqbn}" "${outputPath}" --build-path "${buildDir}" --output-dir "${binDir}" --export-binaries`;

package/src/compilers/CPPCompiler.js

@@ -260,7 +260,7 @@ int main() {
         const pathTo = name => path.join(outputPath, name);
         const targetInfo = this.resolveTarget(target);
 
-        if (outputType === 'executable') {
+        if (this.isExecutableOutput()) {
             const requestedTarget = target ?? `${targetInfo.os}-${targetInfo.arch}`;
             const hostOs = this.getHostOS();
             const hostArch = this.getHostArch();
@@ -271,7 +271,7 @@ int main() {
             const archFlags = this.getArchFlags(targetInfo.os, targetInfo.arch, compiler);
             const formatFlags = (flags = []) => (flags.length ? `${flags.join(' ')} ` : '');
             const isWindowsTarget = targetInfo.os === 'windows';
-            const binDir = path.join(outputPath, 'bin');
+            const binDir = this.getExecutableOutputPath();
             fs.mkdirSync(binDir, { recursive: true });
 
             // Step 2: Compile open62541.c with C compiler

package/src/compilers/Compiler.js

@@ -14,6 +14,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import path from 'path';
+
 export const IECLanguage = Object.freeze({
   LADDER_DIAGRAM: 'LD',
   STRUCTURED_TEXT: 'ST',
@@ -60,6 +62,14 @@ export class Compiler {
     this.options = options;
   }
 
+  isExecutableOutput() {
+    return this.options?.outputType === OutputType.EXECUTABLE;
+  }
+
+  getExecutableOutputPath() {
+    return path.join(this.options.outputPath, 'bin');
+  }
+
   /** @returns {string[]} */
   get supportedLanguages() {
     throw new Error('supportedLanguages must be implemented by subclass.');

package/src/compilers/JSCompiler.js

@@ -224,8 +224,8 @@ export function run(){
         }
         fs.mkdirSync(outputPath, { recursive: true });
         fs.writeFileSync(jsFile, jsCode);
-        const binDir = path.join(outputPath, 'bin');
-        if (outputType === 'executable') {
+        const binDir = this.getExecutableOutputPath();
+        if (this.isExecutableOutput()) {
             fs.mkdirSync(binDir, { recursive: true });
         }
         if(sourcePath.toLowerCase().endsWith(".iec") || sourcePath.toLowerCase().endsWith(".xml") || directoryBundleMode){
@@ -243,34 +243,37 @@ export function run(){
             ];
 
             let coreDir = path.resolve(__dirname + '/support/nodejs');
+            const runtimeOutputDir = this.isExecutableOutput() ? binDir : outputPath;
             
             for (const file of coreFiles) {
-                fs.copyFileSync(path.join(coreDir, file), path.join(outputPath, file));
+                fs.copyFileSync(path.join(coreDir, file), path.join(runtimeOutputDir, file));
             }
-            if (outputType === 'executable') {
-                fs.copyFileSync(jsFile, path.join(binDir, 'nodalisplc.js'));
+            if (this.isExecutableOutput()) {
+                fs.copyFileSync(jsFile, path.join(runtimeOutputDir, 'nodalisplc.js'));
             }
-            writePackageJson(outputPath, plcname);
-            installDependencies(outputPath);
+            writePackageJson(runtimeOutputDir, plcname);
+            installDependencies(runtimeOutputDir);
         }
         
 
-        if (target === "jint" && outputType === "executable") {
+        if (target === "jint" && this.isExecutableOutput()) {
             const supportDir = path.resolve(__dirname, "support/jint/Nodalis");
             const buildScript = os.platform() === "win32" ? "build.bat" : "build.sh";
+            const projectOutputDir = outputPath;
+            const runtimeOutputDir = binDir;
 
-            // 1. Copy all files from support/jint/nodalis to the output directory
-            fs.cpSync(supportDir, outputPath, { recursive: true });
+            // Keep the Jint project sources in the main output directory.
+            fs.cpSync(supportDir, projectOutputDir, { recursive: true, force: true });
 
-            // 2. Run the build script inside the output directory
-            const buildPath = path.resolve(path.join(outputPath, buildScript));
+            // Build from the main output directory, then move publish artifacts under bin.
+            const buildPath = path.resolve(path.join(projectOutputDir, buildScript));
             if(buildPath.endsWith(".sh")){
                 fs.chmodSync(buildPath, 0o755); // make executable
             }
-            execSync(buildPath, { cwd: path.resolve(outputPath), stdio: "inherit", shell: true });
+            execSync(buildPath, { cwd: path.resolve(projectOutputDir), stdio: "inherit", shell: true });
 
             // 3. Copy the generated JS file to each publish folder
-            const publishRoot = path.join(outputPath, "publish");
+            const publishRoot = path.join(projectOutputDir, "publish");
             
             const platforms = fs.readdirSync(publishRoot, { withFileTypes: true })
                 .filter(d => d.isDirectory())
@@ -301,7 +304,7 @@ export function run(){
 
             for (const platformDir of platforms) {
                 const platformName = path.basename(platformDir);
-                const platformBinDir = path.join(binDir, platformName);
+                const platformBinDir = path.join(runtimeOutputDir, platformName);
                 fs.mkdirSync(platformBinDir, { recursive: true });
                 fs.cpSync(platformDir, platformBinDir, { recursive: true, force: true });
             }

package/src/compilers/iec-parser/parser.js

@@ -1845,6 +1845,35 @@ export class Rung extends Serializable {
         return this.Objects.find((v) => v.ID == id);
     }
 
+    /**
+     * Finds the object with the referenced output point ID.
+     * @param {string} refID The ID of the output point to use in searching for the object.
+     * @returns {FbdObject|LdObject} Returns the object with the output, or null if there is no object with that ID.
+     */
+    findObjectWithOutput(refID) {
+        return this.Objects.find(
+            /**
+             * 
+             * @param {FbdObject|LdObject|CommonObject} o 
+             */
+            (o) => {
+                if (o.Type === "Block") {
+                    const v = o.OutputVariables.Variables.find(
+                        /**
+                         * 
+                         * @param {OutputVariable} ov 
+                         */
+                        (ov) => {
+                            return ov.OutputPoint.ID === refID;
+                        });
+                    return typeof ov !== "undefined";
+                }
+                else if (o.Type !== "Comment") {
+                    return typeof o.Outputs.find(op => op.ID === refID) !== "undefined";
+                }
+            });
+    }
+
     /**
      * 
      * @param {LdObject | FbdObject} obj The ladder logic object from which to find connections.
@@ -2084,19 +2113,65 @@ export class Rung extends Serializable {
                 if(expression.length > 0){
                     expression += " OR ";
                 }
-                if(con instanceof FbdObject){
-                    var v = con.OutputVariables.Variables.find(iv => start.hasInput(iv.OutputPoint.ID));
-                    if(isValid(v)){
-                        expression += con.toST(v.ParameterName);
+                if (con instanceof FbdObject) {
+                    const sb = FbdObject.getStandardBlock(con.TypeName);
+                    if (sb && sb.Style === "F") { //this is a function, not a function block.
+                        let fcall = con.TypeName + "(";
+                        forEachElem(con.InputVariables.Variables,
+                            /**
+                             * 
+                             * @param {InputVariable} v 
+                             */
+                            (v) => {
+                                if (v.InputPoint.Connections.length > 0) {
+                                    let assign = "";
+                                    forEachElem(v.InputPoint.Connections,
+                                        /**
+                                         * 
+                                         * @param {Connection} c 
+                                         */
+                                        (c) => {
+                                            const o = this.findObjectWithOutput(c.RefID);
+                                            if (o) {
+                                                if (assign.length > 0) {
+                                                    assign += " OR ";
+                                                }
+                                                assign += this.#buildExpression(o);
+                                            }
+                                        }
+                                    );
+                                    if (v.Negated === "true") {
+                                        assign = "NOT " + assign;
+                                    }
+                                    if (!fcall.endsWith("(")) {
+                                        fcall += ", ";
+                                    }
+                                    fcall += `${v.ParameterName} := ${assign}`;
+                                }
+                            });
+                        expression += `${fcall})`;
                     }
+                    else {
+                        var v = con.OutputVariables.Variables.find(iv => start.hasInput(iv.OutputPoint.ID));
+                        if (isValid(v)) {
+                            expression += con.toST(v.ParameterName);
+                        }
+                    }
+
                 }
                 else if(con.Type !== "LeftPowerRail"){
                     expression += `(${this.#buildExpression(con)})`;
                 }
             }
         );
-        if(start.Type !== "Coil"){
-            expression = `${start.toST()}${expression.length > 0 ? " AND (" + expression + ")" : ""}`;
+        if (start.Type !== "Coil") {
+            if (start.Type === "DataSink") {
+                expression = start.toST("", expression);
+            }
+            else {
+
+                expression = `${start.toST()}${expression.length > 0 ? " AND (" + expression + ")" : ""}`;
+            }
         }
         return expression;  
     }
@@ -2124,6 +2199,34 @@ export class Rung extends Serializable {
                 (block) => {
                     if(done.includes(block.ID)) return;
                     done.push(block.ID);
+                    const sb = FbdObject.getStandardBlock(block.TypeName);
+                    if (typeof sb !== "undefined" && sb.Style === "F") {
+                        //if this is a function and connects with standard ladder logic, then we wait and deal with this in the next step.
+                        //If it doesn't connect with the rest of the rung, then we need to deal with it here.
+                        if (this.findConnections(block, true).find(o => o.Type === "Contact" || o.Type === "CompareContact" || o.Type === "Coil" || o.Type === "RightPowerRail")) {
+                            return;
+                        }
+                        else {
+                            forEachElem(block.OutputVariables.Variables,
+                                /**
+                             * 
+                             * @param {OutputVariable} outvar 
+                             */
+                                (outvar) => {
+
+
+                                    var inobj = this.Objects.find(o => o.hasInput(outvar.OutputPoint.ID));
+                                    if (isValid(inobj)) {
+                                        if (inobj.Type === "DataSink") {
+                                            st += this.#buildExpression(inobj) + ";\n";
+                                        }
+                                    }
+
+                                }
+                            );
+                            return;
+                        }
+                    }
                     forEachElem(block.InputVariables.Variables, 
                         /**
                          * 
@@ -2898,7 +3001,7 @@ export class Connection extends Serializable{
 export class FbdObject extends Serializable {
 
     /**
-     * @type {{TypeName: string, InputVariables: string[], OutputVariables: string[]}[]}
+     * @type {{TypeName: string, InputVariables: string[], OutputVariables: string[], Style: string}[]}
      */
     static StandardBlocks = [
         {

package/src/nodalis.js

@@ -128,11 +128,7 @@ export class Nodalis {
     outputPath,
     resourceName,
     sourcePath,
-    language,
-    codesysCommand,
-    codesysCommandTemplate,
-    codesysProjectFile,
-    codesysPouName
+    language
   }) {
     validateFileExtension(language, sourcePath, resourceName);
 
@@ -147,11 +143,7 @@ export class Nodalis {
       resourceName,
       target,
       outputType,
-      language,
-      codesysCommand,
-      codesysCommandTemplate,
-      codesysProjectFile,
-      codesysPouName
+      language
     };
 
     await compiler.compile();
@@ -203,6 +195,9 @@ Usage:
 Actions:
   --action list-compilers
       Lists all available compilers and their supported targets, languages, protocols, and versions.
+  
+  --action list-programmers
+      Lists all available programmers and their supported targets.
 
   --action compile
       Required options:
@@ -212,10 +207,6 @@ Actions:
         --resourceName  Resource name (used for .iec projects)
         --sourcePath    Path to source file (.st or .iec)
         --language      st (Structured Text) or ld (Ladder Diagram)
-        --codesysCommand Optional CODESYS executable/command for --target codesys
-        --codesysCommandTemplate Optional shell template for --target codesys executable builds
-        --codesysProjectFile Optional .project path for CODESYS automation (defaults to <output>/<resource>.project)
-        --codesysPouName Optional POU name to create/update in CODESYS project
 
   --action deploy  Programs a device based on a protocol.
     --target        The device/protocol targeted for programming.
@@ -261,6 +252,11 @@ Examples:
       console.log(JSON.stringify(list, null, 2));
       break;
     }
+    case 'list-programmers': {
+      const list = app.listProgrammers();
+      console.log(JSON.stringify(list, null, 2));
+      break;
+    }
 
     case 'compile': {
       app.compile({
@@ -269,11 +265,7 @@ Examples:
         outputPath: argMap.outputPath,
         resourceName: argMap.resourceName,
         sourcePath: argMap.sourcePath,
-        language: argMap.language,
-        codesysCommand: argMap.codesysCommand,
-        codesysCommandTemplate: argMap.codesysCommandTemplate,
-        codesysProjectFile: argMap.codesysProjectFile,
-        codesysPouName: argMap.codesysPouName
+        language: argMap.language
       }).then(() => {
         console.log('Compilation completed.');
       }).catch(err => {
@@ -306,7 +298,7 @@ Examples:
 
     default: {
       console.error(`Unknown or missing action: ${argMap.action}`);
-      console.error(`Valid actions: list-compilers, compile, deploy`);
+      console.error(`Valid actions: list-compilers, list-programmers, compile, deploy`);
       break;
     }
   }

package/src/programmers/utils.js

@@ -235,24 +235,41 @@ export async function inferEntryPoint(sourcePath, runtime = 'auto', providedEntr
   }
 
   const candidates = ['nodalisplc', 'nodalisplc.exe', 'nodalisplc.js'];
-  for (const candidate of candidates) {
-    if (await exists(path.join(sourcePath, candidate))) {
-      return candidate;
+  const candidateDirectories = ['bin', ''];
+  for (const directory of candidateDirectories) {
+    for (const candidate of candidates) {
+      const relativeCandidate = directory ? path.join(directory, candidate) : candidate;
+      if (await exists(path.join(sourcePath, relativeCandidate))) {
+        return toPosixPath(relativeCandidate);
+      }
     }
   }
 
+  const inferredRuntime = inferRuntime('', runtime);
+  if (inferredRuntime === 'node') {
+    const binNodeEntry = path.join('bin', 'nodalisplc.js');
+    if (await exists(path.join(sourcePath, binNodeEntry))) {
+      return toPosixPath(binNodeEntry);
+    }
+    return "nodalisplc.js"
+  }
+
   const entries = await fs.readdir(sourcePath, { withFileTypes: true });
   const files = entries.filter(entry => entry.isFile()).map(entry => entry.name);
-  if (files.length === 0) {
-    throw new Error(`Could not infer entry point for source directory: ${sourcePath}`);
+  if (files.length > 0) {
+    return files[0];
   }
 
-  const inferredRuntime = inferRuntime('', runtime);
-  if (inferredRuntime === 'node') {
-    return "nodalisplc.js"
+  const binEntriesPath = path.join(sourcePath, 'bin');
+  if (await exists(binEntriesPath)) {
+    const binEntries = await fs.readdir(binEntriesPath, { withFileTypes: true });
+    const binFiles = binEntries.filter(entry => entry.isFile()).map(entry => entry.name);
+    if (binFiles.length > 0) {
+      return toPosixPath(path.join('bin', binFiles[0]));
+    }
   }
 
-  return files[0];
+  throw new Error(`Could not infer entry point for source directory: ${sourcePath}`);
 }
 
 export function quoteForPosixSingle(value) {