Merge commit '12fce6c' into HEAD

# Conflicts:
#	index.js
#	src/configs/index.js
#	src/configs/machineGroupControl.json
#	src/helper/assetUtils.js
#	src/helper/childRegistrationUtils.js
#	src/helper/configUtils.js
#	src/helper/logger.js
#	src/helper/menuUtils.js
#	src/helper/menuUtils_DEPRECATED.js
#	src/helper/outputUtils.js
#	src/helper/validationUtils.js
#	src/measurements/Measurement.js
#	src/measurements/MeasurementContainer.js
#	src/measurements/examples.js
#	src/outliers/outlierDetection.js

datasets/assetData/curves/index.js

@@ -2,10 +2,11 @@ const fs = require('fs');
 const path = require('path');
 
 class AssetLoader {
-  constructor() {
+  constructor(maxCacheSize = 100) {
     this.relPath = './'
     this.baseDir = path.resolve(__dirname, this.relPath);
-    this.cache = new Map(); // Cache loaded JSON files for better performance
+    this.cache = new Map();
+    this.maxCacheSize = maxCacheSize;
   }
 
   /**
@@ -50,7 +51,11 @@ class AssetLoader {
       const rawData = fs.readFileSync(filePath, 'utf8');
       const assetData = JSON.parse(rawData);
       
-      // Cache the result
+      // Cache the result (evict oldest if at capacity)
+      if (this.cache.size >= this.maxCacheSize) {
+        const oldestKey = this.cache.keys().next().value;
+        this.cache.delete(oldestKey);
+      }
       this.cache.set(cacheKey, assetData);
       
       return assetData;

index.js

@@ -31,7 +31,9 @@ const MenuManager = require('./src/menu/index.js');
 const { predict, interpolation } = require('./src/predict/index.js');
 const { PIDController, CascadePIDController, createPidController, createCascadePidController } = require('./src/pid/index.js');
 const { loadCurve } = require('./datasets/assetData/curves/index.js'); //deprecated replace with load model data
-const { loadModel } = require('./datasets/assetData/modelData/index.js'); 
+const { loadModel } = require('./datasets/assetData/modelData/index.js');
+const { POSITIONS, POSITION_VALUES, isValidPosition } = require('./src/constants/positions.js');
+const Fysics = require('./src/convert/fysics.js');
 
 // Export everything
 module.exports = {
@@ -57,5 +59,9 @@ module.exports = {
     childRegistrationUtils,
     loadCurve, //deprecated replace with loadModel
     loadModel,
-    gravity
+    gravity,
+    POSITIONS,
+    POSITION_VALUES,
+    isValidPosition,
+    Fysics
 };

src/configs/baseConfig.json

@@ -0,0 +1,85 @@
+{
+  "general": {
+    "name": {
+      "default": "Unnamed Node",
+      "rules": { "type": "string", "description": "Human-readable name for this node." }
+    },
+    "id": {
+      "default": null,
+      "rules": { "type": "string", "nullable": true, "description": "Unique node identifier (set at runtime)." }
+    },
+    "unit": {
+      "default": "unitless",
+      "rules": { "type": "string", "description": "Default measurement unit." }
+    },
+    "logging": {
+      "logLevel": {
+        "default": "info",
+        "rules": {
+          "type": "enum",
+          "values": [
+            { "value": "debug", "description": "Verbose diagnostic messages." },
+            { "value": "info", "description": "General informational messages." },
+            { "value": "warn", "description": "Warning messages." },
+            { "value": "error", "description": "Error level messages only." }
+          ]
+        }
+      },
+      "enabled": {
+        "default": true,
+        "rules": { "type": "boolean", "description": "Enable or disable logging." }
+      }
+    }
+  },
+  "functionality": {
+    "softwareType": {
+      "default": "unknown",
+      "rules": { "type": "string", "description": "Software type identifier for parent-child registration." }
+    },
+    "role": {
+      "default": "Generic EVOLV node",
+      "rules": { "type": "string", "description": "Describes the functional role of this node." }
+    },
+    "positionVsParent": {
+      "default": "atEquipment",
+      "rules": {
+        "type": "enum",
+        "values": [
+          { "value": "upstream", "description": "Upstream of parent equipment." },
+          { "value": "atEquipment", "description": "At equipment level." },
+          { "value": "downstream", "description": "Downstream of parent equipment." }
+        ]
+      }
+    }
+  },
+  "asset": {
+    "uuid": {
+      "default": null,
+      "rules": { "type": "string", "nullable": true, "description": "Asset UUID from asset management system." }
+    },
+    "tagCode": {
+      "default": null,
+      "rules": { "type": "string", "nullable": true, "description": "Asset tag code." }
+    },
+    "supplier": {
+      "default": "Unknown",
+      "rules": { "type": "string", "description": "Equipment supplier." }
+    },
+    "category": {
+      "default": "sensor",
+      "rules": { "type": "string", "description": "Asset category." }
+    },
+    "type": {
+      "default": "Unknown",
+      "rules": { "type": "string", "description": "Asset type." }
+    },
+    "model": {
+      "default": "Unknown",
+      "rules": { "type": "string", "description": "Equipment model." }
+    },
+    "unit": {
+      "default": "unitless",
+      "rules": { "type": "string", "description": "Asset measurement unit." }
+    }
+  }
+}

src/configs/diffuser.json

@@ -0,0 +1,111 @@
+{
+  "general": {
+    "name": {
+      "default": "Diffuser",
+      "rules": {
+        "type": "string",
+        "description": "A human-readable name for this diffuser zone."
+      }
+    },
+    "id": {
+      "default": null,
+      "rules": {
+        "type": "string",
+        "nullable": true,
+        "description": "Unique identifier for this diffuser node."
+      }
+    },
+    "unit": {
+      "default": "Nm3/h",
+      "rules": {
+        "type": "string",
+        "description": "Default airflow unit for this diffuser."
+      }
+    },
+    "logging": {
+      "logLevel": {
+        "default": "info",
+        "rules": {
+          "type": "enum",
+          "values": [
+            { "value": "debug", "description": "Verbose diagnostic messages." },
+            { "value": "info", "description": "General informational messages." },
+            { "value": "warn", "description": "Warning messages." },
+            { "value": "error", "description": "Error level messages only." }
+          ]
+        }
+      },
+      "enabled": {
+        "default": true,
+        "rules": {
+          "type": "boolean",
+          "description": "Enable or disable logging."
+        }
+      }
+    }
+  },
+  "functionality": {
+    "softwareType": {
+      "default": "diffuser",
+      "rules": {
+        "type": "string",
+        "description": "Software type identifier for parent-child registration."
+      }
+    },
+    "role": {
+      "default": "Aeration diffuser",
+      "rules": {
+        "type": "string",
+        "description": "Describes the functional role of this node."
+      }
+    },
+    "positionVsParent": {
+      "default": "atEquipment",
+      "rules": {
+        "type": "enum",
+        "values": [
+          { "value": "upstream", "description": "Upstream of parent equipment." },
+          { "value": "atEquipment", "description": "At equipment level." },
+          { "value": "downstream", "description": "Downstream of parent equipment." }
+        ]
+      }
+    }
+  },
+  "diffuser": {
+    "number": {
+      "default": 1,
+      "rules": {
+        "type": "number",
+        "description": "Sequential diffuser zone number."
+      }
+    },
+    "elements": {
+      "default": 1,
+      "rules": {
+        "type": "number",
+        "description": "Number of diffuser elements in the zone."
+      }
+    },
+    "density": {
+      "default": 2.4,
+      "rules": {
+        "type": "number",
+        "description": "Installed diffuser density per square meter."
+      }
+    },
+    "waterHeight": {
+      "default": 0,
+      "rules": {
+        "type": "number",
+        "description": "Water column height above the diffuser."
+      }
+    },
+    "alfaFactor": {
+      "default": 0.7,
+      "rules": {
+        "type": "number",
+        "description": "Alpha factor used for oxygen transfer correction."
+      }
+    }
+  }
+}

src/configs/index.js

@@ -1,22 +1,52 @@
 const fs = require('fs');
 const path = require('path');
 
+/**
+ * Current config version. All config JSONs should declare this version.
+ * Bump this when the config schema changes.
+ */
+const CURRENT_CONFIG_VERSION = '1.0.0';
+
 class ConfigManager {
     constructor(relPath = '.') {
         this.configDir = path.resolve(__dirname, relPath);
+
+        /**
+         * Migration functions keyed by "fromVersion->toVersion".
+         * Each function receives a config object and returns the migrated config.
+         *
+         * Example:
+         *   this.migrations['1.0.0->1.1.0'] = (config) => {
+         *       config.newSection = { enabled: false };
+         *       return config;
+         *   };
+         */
+        this.migrations = {};
     }
 
     /**
-     * Load a configuration file by name
+     * Load a configuration file by name.
+     * Automatically checks the config version and migrates if needed.
      * @param {string} configName - Name of the config file (without .json extension)
-     * @returns {Object} Parsed configuration object
+     * @returns {Object} Parsed configuration object (migrated to current version if necessary)
      */
     getConfig(configName) {
         try {
             const configPath = path.resolve(this.configDir, `${configName}.json`);
             const configData = fs.readFileSync(configPath, 'utf8');
-            return JSON.parse(configData);
+            let config = JSON.parse(configData);
+
+            // Auto-migrate if version is behind current
+            const configVersion = config.version || '0.0.0';
+            if (configVersion !== CURRENT_CONFIG_VERSION) {
+                config = this.migrateConfig(config, configVersion, CURRENT_CONFIG_VERSION);
+            }
+
+            return config;
         } catch (error) {
+            if (error.message && error.message.startsWith('Failed to load config')) {
+                throw error;
+            }
             throw new Error(`Failed to load config '${configName}': ${error.message}`);
         }
     }
@@ -47,6 +77,94 @@ class ConfigManager {
         return fs.existsSync(configPath);
     }
 
+    /**
+     * Build a runtime config by merging base schema + node schema + UI overrides.
+     * Eliminates the need for each nodeClass to manually construct general/asset/functionality sections.
+     *
+     * @param {string} nodeName - Node type name (e.g., 'valve', 'measurement')
+     * @param {object} uiConfig - Raw config from Node-RED UI
+     * @param {string} nodeId - Node-RED node ID (from node.id)
+     * @param {object} [domainConfig={}] - Domain-specific config sections (e.g., { scaling: {...}, smoothing: {...} })
+     * @returns {object} Merged runtime config
+     *
+     * @example
+     * const cfgMgr = new ConfigManager();
+     * const config = cfgMgr.buildConfig('measurement', uiConfig, node.id, {
+     *   scaling: { enabled: uiConfig.scaling, inputMin: uiConfig.i_min, ... },
+     *   smoothing: { smoothWindow: uiConfig.count, ... }
+     * });
+     */
+    buildConfig(nodeName, uiConfig, nodeId, domainConfig = {}) {
+        // Build base sections from UI config (common to ALL nodes)
+        const config = {
+            general: {
+                name: uiConfig.name || nodeName,
+                id: nodeId,
+                unit: uiConfig.unit || 'unitless',
+                logging: {
+                    enabled: uiConfig.enableLog !== undefined ? uiConfig.enableLog : true,
+                    logLevel: uiConfig.logLevel || 'info'
+                }
+            },
+            functionality: {
+                softwareType: nodeName.toLowerCase(),
+                positionVsParent: uiConfig.positionVsParent || 'atEquipment',
+                distance: uiConfig.hasDistance ? uiConfig.distance : undefined
+            },
+            output: {
+                process: uiConfig.processOutputFormat || 'process',
+                dbase: uiConfig.dbaseOutputFormat || 'influxdb'
+            }
+        };
+
+        // Add asset section if UI provides asset fields
+        if (uiConfig.supplier || uiConfig.category || uiConfig.assetType || uiConfig.model) {
+            config.asset = {
+                uuid: uiConfig.uuid || uiConfig.assetUuid || null,
+                tagCode: uiConfig.tagCode || uiConfig.assetTagCode || null,
+                supplier: uiConfig.supplier || 'Unknown',
+                category: uiConfig.category || 'sensor',
+                type: uiConfig.assetType || 'Unknown',
+                model: uiConfig.model || 'Unknown',
+                unit: uiConfig.unit || 'unitless'
+            };
+        }
+
+        // Merge domain-specific sections
+        Object.assign(config, domainConfig);
+
+        return config;
+    }
+
+    /**
+     * Migrate a config object from one version to another by applying
+     * registered migration functions in sequence.
+     * @param {object} config - The config object to migrate
+     * @param {string} fromVersion - Current version of the config
+     * @param {string} toVersion - Target version
+     * @returns {object} Migrated config with updated version field
+     */
+    migrateConfig(config, fromVersion, toVersion) {
+        const migrationKey = `${fromVersion}->${toVersion}`;
+        const migrationFn = this.migrations[migrationKey];
+
+        if (migrationFn) {
+            config = migrationFn(config);
+        }
+
+        // Stamp the current version so it won't re-migrate
+        config.version = toVersion;
+        return config;
+    }
+
+    /**
+     * Get the base config schema (shared across all nodes).
+     * @returns {object} Base config schema
+     */
+    getBaseConfig() {
+        return this.getConfig('baseConfig');
+    }
+
     createEndpoint(nodeName) {
         try {
             // Load the config for this node
@@ -73,4 +191,4 @@ class ConfigManager {
     }
 }
 
-module.exports = ConfigManager;
+module.exports = ConfigManager;

src/configs/machineGroupControl.json

@@ -58,10 +58,10 @@
     },
     "functionality": {
       "softwareType": {
-        "default": "machinegroup",
-          "rules": {
-            "type": "string",
-            "description": "Logical name identifying the software type."
+        "default": "machinegroupcontrol",
+        "rules": {
+          "type": "string",
+          "description": "Logical name identifying the software type."
         }
       },
       "role": {

src/configs/reactor.json

@@ -0,0 +1,202 @@
+{
+    "general": {
+      "name": {
+        "default": "Reactor",
+        "rules": {
+          "type": "string",
+          "description": "A human-readable name for this reactor."
+        }
+      },
+      "id": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "Unique identifier for this reactor node."
+        }
+      },
+      "unit": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "Default measurement unit."
+        }
+      },
+      "logging": {
+        "logLevel": {
+          "default": "info",
+          "rules": {
+            "type": "enum",
+            "values": [
+              { "value": "debug", "description": "Verbose diagnostic messages." },
+              { "value": "info", "description": "General informational messages." },
+              { "value": "warn", "description": "Warning messages." },
+              { "value": "error", "description": "Error level messages only." }
+            ]
+          }
+        },
+        "enabled": {
+          "default": true,
+          "rules": {
+            "type": "boolean",
+            "description": "Enable or disable logging."
+          }
+        }
+      }
+    },
+    "functionality": {
+      "softwareType": {
+        "default": "reactor",
+        "rules": {
+          "type": "string",
+          "description": "Software type identifier for parent-child registration."
+        }
+      },
+      "role": {
+        "default": "Biological reactor for wastewater treatment",
+        "rules": {
+          "type": "string",
+          "description": "Describes the functional role of this node."
+        }
+      },
+      "positionVsParent": {
+        "default": "atEquipment",
+        "rules": {
+          "type": "enum",
+          "values": [
+            { "value": "upstream", "description": "Upstream of parent equipment." },
+            { "value": "atEquipment", "description": "At equipment level." },
+            { "value": "downstream", "description": "Downstream of parent equipment." }
+          ]
+        }
+      }
+    },
+    "reactor": {
+      "reactor_type": {
+        "default": "CSTR",
+        "rules": {
+          "type": "enum",
+          "values": [
+            { "value": "CSTR", "description": "Continuous Stirred Tank Reactor - fully mixed." },
+            { "value": "PFR", "description": "Plug Flow Reactor - spatial gradient along length." }
+          ]
+        }
+      },
+      "volume": {
+        "default": 1000,
+        "rules": {
+          "type": "number",
+          "min": 0,
+          "unit": "m3",
+          "description": "Reactor volume in cubic meters."
+        }
+      },
+      "length": {
+        "default": 10,
+        "rules": {
+          "type": "number",
+          "min": 0,
+          "unit": "m",
+          "description": "Reactor length (relevant for PFR spatial discretization)."
+        }
+      },
+      "resolution_L": {
+        "default": 10,
+        "rules": {
+          "type": "integer",
+          "min": 1,
+          "description": "Number of spatial segments for PFR discretization."
+        }
+      },
+      "alpha": {
+        "default": 0.5,
+        "rules": {
+          "type": "number",
+          "min": 0,
+          "max": 1,
+          "description": "Dispersion coefficient alpha (0 = plug flow, 1 = fully mixed)."
+        }
+      },
+      "n_inlets": {
+        "default": 1,
+        "rules": {
+          "type": "integer",
+          "min": 1,
+          "description": "Number of inlet points along the reactor."
+        }
+      },
+      "kla": {
+        "default": 0,
+        "rules": {
+          "type": "number",
+          "min": 0,
+          "unit": "1/h",
+          "description": "Oxygen mass transfer coefficient (KLa)."
+        }
+      },
+      "timeStep": {
+        "default": 0.001,
+        "rules": {
+          "type": "number",
+          "min": 0.0001,
+          "unit": "h",
+          "description": "Integration time step for the reactor model."
+        }
+      }
+    },
+    "initialState": {
+      "S_O": {
+        "default": 0,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial dissolved oxygen concentration." }
+      },
+      "S_I": {
+        "default": 30,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial inert soluble COD." }
+      },
+      "S_S": {
+        "default": 70,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial readily biodegradable substrate." }
+      },
+      "S_NH": {
+        "default": 25,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial ammonium nitrogen." }
+      },
+      "S_N2": {
+        "default": 0,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial dinitrogen (N2)." }
+      },
+      "S_NO": {
+        "default": 0,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial nitrate and nitrite nitrogen." }
+      },
+      "S_HCO": {
+        "default": 5,
+        "rules": { "type": "number", "unit": "mmol/L", "description": "Initial alkalinity (bicarbonate)." }
+      },
+      "X_I": {
+        "default": 1000,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial inert particulate COD." }
+      },
+      "X_S": {
+        "default": 100,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial slowly biodegradable substrate." }
+      },
+      "X_H": {
+        "default": 2000,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial heterotrophic biomass." }
+      },
+      "X_STO": {
+        "default": 0,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial stored COD in biomass." }
+      },
+      "X_A": {
+        "default": 200,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial autotrophic biomass." }
+      },
+      "X_TS": {
+        "default": 3500,
+        "rules": { "type": "number", "unit": "mg/L", "description": "Initial total suspended solids." }
+      }
+    }
+  }

src/configs/rotatingMachine.json

@@ -58,7 +58,7 @@
     },
     "functionality": {
       "softwareType": {
-        "default": "machine",
+        "default": "rotatingmachine",
           "rules": {
             "type": "string",
             "description": "Specified software type for this configuration."

src/configs/settler.json

@@ -0,0 +1,75 @@
+{
+    "general": {
+      "name": {
+        "default": "Settler",
+        "rules": {
+          "type": "string",
+          "description": "A human-readable name for this settler."
+        }
+      },
+      "id": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "Unique identifier for this settler node."
+        }
+      },
+      "unit": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "Default measurement unit."
+        }
+      },
+      "logging": {
+        "logLevel": {
+          "default": "info",
+          "rules": {
+            "type": "enum",
+            "values": [
+              { "value": "debug", "description": "Verbose diagnostic messages." },
+              { "value": "info", "description": "General informational messages." },
+              { "value": "warn", "description": "Warning messages." },
+              { "value": "error", "description": "Error level messages only." }
+            ]
+          }
+        },
+        "enabled": {
+          "default": true,
+          "rules": {
+            "type": "boolean",
+            "description": "Enable or disable logging."
+          }
+        }
+      }
+    },
+    "functionality": {
+      "softwareType": {
+        "default": "settler",
+        "rules": {
+          "type": "string",
+          "description": "Software type identifier for parent-child registration."
+        }
+      },
+      "role": {
+        "default": "Secondary settler for sludge separation",
+        "rules": {
+          "type": "string",
+          "description": "Describes the functional role of this node."
+        }
+      },
+      "positionVsParent": {
+        "default": "downstream",
+        "rules": {
+          "type": "enum",
+          "values": [
+            { "value": "upstream", "description": "Upstream of parent equipment." },
+            { "value": "atEquipment", "description": "At equipment level." },
+            { "value": "downstream", "description": "Downstream of parent equipment." }
+          ]
+        }
+      }
+    }
+  }

src/configs/valveGroupControl.json

@@ -60,7 +60,7 @@
     },
     "functionality": {
       "softwareType": {
-        "default": "valveGroupControl",
+        "default": "valvegroupcontrol",
           "rules": {
             "type": "string",
             "description": "Specified software type for this configuration."

src/constants/positions.js

@@ -0,0 +1,18 @@
+/**
+ * Canonical position constants for parent-child relationships.
+ * Use these instead of hardcoded strings throughout the codebase.
+ */
+const POSITIONS = Object.freeze({
+  UPSTREAM: 'upstream',
+  DOWNSTREAM: 'downstream',
+  AT_EQUIPMENT: 'atEquipment',
+  DELTA: 'delta',
+});
+
+const POSITION_VALUES = Object.freeze(Object.values(POSITIONS));
+
+function isValidPosition(pos) {
+  return POSITION_VALUES.includes(pos);
+}
+
+module.exports = { POSITIONS, POSITION_VALUES, isValidPosition };

src/convert/definitions/each.js

@@ -1,5 +1,4 @@
-var metric
-  , imperial;
+var metric;
 
 metric = {
   ea: {

src/convert/definitions/illuminance.js

@@ -30,8 +30,8 @@ module.exports = {
       ratio: 1/10.76391
     },
     imperial: {
-      unit: 'ft-cd',      
-	  ratio: 10.76391
+      unit: 'ft-cd',
+      ratio: 10.76391
     }
   }
 };

src/convert/definitions/partsPer.js

@@ -1,5 +1,4 @@
-var metric
-  , imperial;
+var metric;
 
 metric = {
   ppm: {

src/convert/index.js

@@ -127,7 +127,7 @@ Converter.prototype.toBest = function(options) {
   if(!this.origin)
     throw new Error('.toBest must be called after .from');
 
-  var options = Object.assign({
+  options = Object.assign({
     exclude: [],
     cutOffNumber: 1,
   }, options)
@@ -249,7 +249,7 @@ Converter.prototype.list = function (measure) {
 Converter.prototype.throwUnsupportedUnitError = function (what) {
   var validUnits = [];
 
-  each(measures, function (systems, measure) {
+  each(measures, function (systems, _measure) {
     each(systems, function (units, system) {
       if(system == '_anchors')
         return false;
@@ -268,22 +268,22 @@ Converter.prototype.throwUnsupportedUnitError = function (what) {
 Converter.prototype.possibilities = function (measure) {
   var possibilities = [];
   if(!this.origin && !measure) {
-	  each(keys(measures), function (measure){
-		  each(measures[measure], function (units, system) {
-		    if(system == '_anchors')
-		      return false;
+    each(keys(measures), function (measure){
+      each(measures[measure], function (units, system) {
+        if(system == '_anchors')
+          return false;
 
-		    possibilities = possibilities.concat(keys(units));
-		  });
-	  });
+        possibilities = possibilities.concat(keys(units));
+      });
+    });
   } else {
-	  measure = measure || this.origin.measure;
-	  each(measures[measure], function (units, system) {
-	    if(system == '_anchors')
-	      return false;
+    measure = measure || this.origin.measure;
+    each(measures[measure], function (units, system) {
+      if(system == '_anchors')
+        return false;
 
-	    possibilities = possibilities.concat(keys(units));
-	  });
+      possibilities = possibilities.concat(keys(units));
+    });
   }
 
   return possibilities;

src/convert/lodash/lodash._basecreate/index.js

@@ -7,7 +7,6 @@
  * Available under MIT license <http://lodash.com/license>
  */
 var isObject = require('./../lodash.isobject'),
-    noop = require('./../lodash.noop'),
     reNative = require('./../lodash._renative');
 
 /* Native method shortcuts for methods with the same name as other `lodash` methods */
@@ -21,12 +20,12 @@ var nativeCreate = reNative.test(nativeCreate = Object.create) && nativeCreate;
  * @param {Object} prototype The object to inherit from.
  * @returns {Object} Returns the new object.
  */
-function baseCreate(prototype, properties) {
+function baseCreate(prototype, _properties) { // eslint-disable-line no-func-assign
   return isObject(prototype) ? nativeCreate(prototype) : {};
 }
 // fallback for browsers without `Object.create`
 if (!nativeCreate) {
-  baseCreate = (function() {
+  baseCreate = (function() { // eslint-disable-line no-func-assign
     function Object() {}
     return function(prototype) {
       if (isObject(prototype)) {

src/convert/lodash/lodash._createwrapper/index.js

@@ -47,7 +47,7 @@ function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, ar
   var isBind = bitmask & 1,
       isBindKey = bitmask & 2,
       isCurry = bitmask & 4,
-      isCurryBound = bitmask & 8,
+      /* isCurryBound = bitmask & 8, */
       isPartial = bitmask & 16,
       isPartialRight = bitmask & 32;
 

src/convert/lodash/lodash._setbinddata/index.js

@@ -24,7 +24,7 @@ var defineProperty = (function() {
     var o = {},
         func = reNative.test(func = Object.defineProperty) && func,
         result = func(o, o, o) && func;
-  } catch(e) { }
+  } catch(e) { /* intentionally empty */ }
   return result;
 }());
 

src/convert/lodash/lodash.bind/index.js

@@ -7,7 +7,6 @@
  * Available under MIT license <http://lodash.com/license>
  */
 var createWrapper = require('./../lodash._createwrapper'),
-    reNative = require('./../lodash._renative'),
     slice = require('./../lodash._slice');
 
 /**

src/helper/assetUtils.js

@@ -241,4 +241,4 @@ module.exports = {
   syncAsset,
   buildAssetPayload,
   findModelMetadata
-};
+};

src/helper/childRegistrationUtils.js

@@ -15,7 +15,7 @@ class ChildRegistrationUtils {
       return false;
     }
 
-    const softwareType = child.config.functionality.softwareType;
+    const softwareType = (child.config.functionality.softwareType || '').toLowerCase();
     const name = child.config.general.name || child.config.general.id || 'unknown';
     const id = child.config.general.id || name;
 
@@ -49,7 +49,7 @@ class ChildRegistrationUtils {
 
     // IMPORTANT: Only call parent registration - no automatic handling and if parent has this function then try to register this child
     if (typeof this.mainClass.registerChild === 'function') {
-      this.mainClass.registerChild(child, softwareType);
+      return this.mainClass.registerChild(child, softwareType);
     }
 
     this.logger.info(`✅ Child ${name} registered successfully`);

src/helper/childRegistrationUtils_DEPRECATED.js

@@ -1,260 +0,0 @@
-// ChildRegistrationUtils.js
-class ChildRegistrationUtils {
-  constructor(mainClass) {
-    this.mainClass = mainClass; // Reference to the main class
-    this.logger = mainClass.logger;
-  }
-
-  async registerChild(child, positionVsParent) {
-
-    this.logger.debug(`Registering child: ${child.id} with position=${positionVsParent}`);
-    const { softwareType } = child.config.functionality;
-    const { name, id, unit } = child.config.general;
-    const { category = "", type = "" } = child.config.asset || {};
-    console.log(`Registering child: ${name}, id: ${id}, softwareType: ${softwareType}, category: ${category}, type: ${type}, positionVsParent: ${positionVsParent}` );
-    const emitter = child.emitter;
-
-    //define position vs parent in child
-    child.positionVsParent = positionVsParent;
-    child.parent = this.mainClass;
-
-    if (!this.mainClass.child) this.mainClass.child = {};
-    if (!this.mainClass.child[softwareType])
-      this.mainClass.child[softwareType] = {};
-    if (!this.mainClass.child[softwareType][category])
-      this.mainClass.child[softwareType][category] = {};
-    if (!this.mainClass.child[softwareType][category][type])
-      this.mainClass.child[softwareType][category][type] = {};
-
-    // Use an array to handle multiple categories
-    if (!Array.isArray(this.mainClass.child[softwareType][category][type])) {
-      this.mainClass.child[softwareType][category][type] = [];
-    }
-
-    // Push the new child to the array of the mainclass so we can track the childs
-    this.mainClass.child[softwareType][category][type].push({
-      name,
-      id,
-      unit,
-      emitter,
-    });
-
-    //then connect the child depending on the type type etc..
-    this.connectChild(
-      id,
-      softwareType,
-      emitter,
-      category,
-      child,
-      type,
-      positionVsParent
-    );
-  }
-
-  connectChild(
-    id,
-    softwareType,
-    emitter,
-    category,
-    child,
-    type,
-    positionVsParent
-  ) {
-    this.logger.debug(
-      `Connecting child id=${id}: desc=${softwareType}, category=${category},type=${type}, position=${positionVsParent}`
-    );
-
-    switch (softwareType) {
-      case "measurement":
-        this.logger.debug(
-          `Registering measurement child: ${id} with category=${category}`
-        );
-        this.connectMeasurement(child, type, positionVsParent);
-        break;
-
-      case "machine":
-        this.logger.debug(`Registering complete machine child: ${id}`);
-        this.connectMachine(child);
-        break;
-
-      case "valve":
-        this.logger.debug(`Registering complete valve child: ${id}`);
-        this.connectValve(child);
-        break;
-
-      case "machineGroup":
-        this.logger.debug(`Registering complete machineGroup child: ${id}`);
-        this.connectMachineGroup(child);
-        break;
-
-      case "actuator":
-        this.logger.debug(`Registering linear actuator child: ${id}`);
-        this.connectActuator(child,positionVsParent);
-        break;
-
-      default:
-        this.logger.error(`Child registration unrecognized desc: ${desc}`);
-        this.logger.error(`Unrecognized softwareType: ${softwareType}`);
-    }
-  }
-
-  connectMeasurement(child, type, position) {
-    this.logger.debug(
-      `Connecting measurement child: ${type} with position=${position}`
-    );
-
-    // Check if type is valid
-    if (!type) {
-      this.logger.error(`Invalid type for measurement: ${type}`);
-      return;
-    }
-
-    // initialize the measurement to a number - logging each step for debugging
-    try {
-      this.logger.debug(
-        `Initializing measurement: ${type}, position: ${position} value: 0`
-      );
-      const typeResult = this.mainClass.measurements.type(type);
-      const variantResult = typeResult.variant("measured");
-      const positionResult = variantResult.position(position);
-      positionResult.value(0);
-
-      this.logger.debug(
-        `Subscribing on mAbs event for measurement: ${type}, position: ${position}`
-      );
-      // Listen for the mAbs event and update the measurement
-
-      this.logger.debug(
-        `Successfully initialized measurement: ${type}, position: ${position}`
-      );
-    } catch (error) {
-      this.logger.error(`Failed to initialize measurement: ${error.message}`);
-      return;
-    }
-
-    //testing new emitter strategy
-    child.measurements.emitter.on("newValue", (data) => {
-      this.logger.warn(
-        `Value change event received for measurement: ${type}, position: ${position}, value: ${data.value}`
-      );
-    });
-
-    child.emitter.on("mAbs", (value) => {
-      // Use the same method chaining approach that worked during initialization
-      this.mainClass.measurements
-        .type(type)
-        .variant("measured")
-        .position(position)
-        .value(value);
-      this.mainClass.updateMeasurement("measured", type, value, position);
-      //this.logger.debug(`--------->>>>>>>>>Updated measurement: ${type}, value: ${value}, position: ${position}`);
-    });
-    
-  }
-
-  connectMachine(machine) {
-    if (!machine) {
-      this.logger.error("Invalid machine provided.");
-      return;
-    }
-
-    const machineId = Object.keys(this.mainClass.machines).length + 1;
-    this.mainClass.machines[machineId] = machine;
-
-    this.logger.info(
-      `Setting up pressureChange listener for machine ${machineId}`
-    );
-
-    machine.emitter.on("pressureChange", () =>
-      this.mainClass.handlePressureChange(machine)
-    );
-
-    //update of child triggers the handler
-    this.mainClass.handleChildChange();
-
-    this.logger.info(`Machine ${machineId} registered successfully.`);
-  }
-
-  connectValve(valve) {
-    if (!valve) {
-      this.logger.warn("Invalid valve provided.");
-      return;
-    }
-    const valveId = Object.keys(this.mainClass.valves).length + 1;
-    this.mainClass.valves[valveId] = valve; // Gooit valve object in de valves attribute met valve objects
-
-    valve.state.emitter.on("positionChange", (data) => {
-      //ValveGroupController abboneren op klepstand verandering
-      this.mainClass.logger.debug(`Position change of valve detected: ${data}`);
-      this.mainClass.calcValveFlows();
-    }); //bepaal nieuwe flow per valve
-    valve.emitter.on("deltaPChange", () => {
-      this.mainClass.logger.debug("DeltaP change of valve detected");
-      this.mainClass.calcMaxDeltaP();
-    }); //bepaal nieuwe max deltaP
-
-    this.logger.info(`Valve ${valveId} registered successfully.`);
-  }
-
-  connectMachineGroup(machineGroup) {
-    if (!machineGroup) {
-        this.logger.warn("Invalid machineGroup provided.");
-        return;
-    }
-
-    try {
-    const machineGroupId = Object.keys(this.mainClass.machineGroups).length + 1;
-    this.mainClass.machineGroups[machineGroupId] = machineGroup; 
-    } catch (error) {
-      this.logger.warn(`Skip machinegroup connnection: ${error.message}`);
-    }
-
-    machineGroup.emitter.on("totalFlowChange", (data) => {
-      this.mainClass.logger.debug('Total flow change of machineGroup detected');
-      this.mainClass.handleInput("parent", "totalFlowChange", data)}); //Geef nieuwe totale flow door aan valveGrouControl
-
-    this.logger.info(`MachineGroup ${machineGroup.config.general.name} registered successfully.`);
-    }
-
-  connectActuator(actuator, positionVsParent) {
-    if (!actuator) {
-      this.logger.warn("Invalid actuator provided.");
-      return;
-    }
-
-    //Special case gateGroupControl
-    if (
-      this.mainClass.config.functionality.softwareType == "gateGroupControl"
-    ) {
-      if (Object.keys(this.mainClass.actuators).length < 2) {
-        if (positionVsParent == "downstream") {
-          this.mainClass.actuators[0] = actuator;
-        }
-
-        if (positionVsParent == "upstream") {
-          this.mainClass.actuators[1] = actuator;
-        }
-        //define emitters
-        actuator.state.emitter.on("positionChange", (data) => {
-          this.mainClass.logger.debug(`Position change of actuator detected: ${data}`);
-          this.mainClass.eventUpdate();
-        }); 
-
-        //define emitters
-        actuator.state.emitter.on("stateChange", (data) => {
-          this.mainClass.logger.debug(`State change of actuator detected: ${data}`);
-          this.mainClass.eventUpdate();
-        }); 
-
-      } else {
-        this.logger.error(
-          "Too many actuators registered. Only two are allowed."
-        );
-      }
-    }
-  }
-
-  //wanneer hij deze ontvangt is deltaP van een van de valves veranderd (kan ook zijn niet child zijn, maar dat maakt niet uit)
-}
-
-module.exports = ChildRegistrationUtils;

src/helper/configUtils.js

@@ -80,7 +80,7 @@ class ConfigUtils {
     // loop through objects and merge them obj1 will be updated with obj2 values
     mergeObjects(obj1, obj2) {
         for (let key in obj2) {
-            if (obj2.hasOwnProperty(key)) {
+            if (Object.prototype.hasOwnProperty.call(obj2, key)) {
                 const nextValue = obj2[key];
 
                 if (Array.isArray(nextValue)) {

src/helper/formatters/csvFormatter.js

@@ -0,0 +1,44 @@
+/**
+ * CSV formatter
+ * Produces a single CSV line: timestamp,measurement,field1=val1,field2=val2,...
+ *
+ * Values are escaped if they contain commas or quotes.
+ *
+ * @param {string} measurement - The measurement name (e.g. node name)
+ * @param {object} metadata    - { fields, tags }
+ *   - fields: key/value pairs of changed data points
+ *   - tags:   flat key/value string pairs (included as columns)
+ * @returns {string} CSV-formatted line
+ */
+function format(measurement, metadata) {
+  const { fields, tags } = metadata;
+  const timestamp = new Date().toISOString();
+  const parts = [escapeCSV(timestamp), escapeCSV(measurement)];
+
+  // Append tags first, then fields
+  if (tags) {
+    for (const key of Object.keys(tags).sort()) {
+      parts.push(escapeCSV(`${key}=${tags[key]}`));
+    }
+  }
+
+  for (const key of Object.keys(fields).sort()) {
+    parts.push(escapeCSV(`${key}=${fields[key]}`));
+  }
+
+  return parts.join(',');
+}
+
+/**
+ * Escapes a value for safe inclusion in a CSV field.
+ * Wraps in double quotes if the value contains a comma, quote, or newline.
+ */
+function escapeCSV(value) {
+  const str = String(value);
+  if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+    return '"' + str.replace(/"/g, '""') + '"';
+  }
+  return str;
+}
+
+module.exports = { format };

src/helper/formatters/index.js

@@ -0,0 +1,60 @@
+/**
+ * Formatter Registry
+ * ------------------
+ * Maps format names to formatter modules.
+ * Each formatter exports: format(measurement, metadata) => string|object
+ *
+ * Usage:
+ *   const { getFormatter, registerFormatter } = require('./formatters');
+ *   const fmt = getFormatter('json');
+ *   const output = fmt.format('pump1', { fields: {...}, tags: {...} });
+ */
+
+const influxdbFormatter = require('./influxdbFormatter');
+const jsonFormatter = require('./jsonFormatter');
+const csvFormatter = require('./csvFormatter');
+const processFormatter = require('./processFormatter');
+
+// Built-in registry
+const registry = {
+  influxdb: influxdbFormatter,
+  json: jsonFormatter,
+  csv: csvFormatter,
+  process: processFormatter,
+};
+
+/**
+ * Retrieve a formatter by name.
+ * @param {string} name - Format name (e.g. 'influxdb', 'json', 'csv')
+ * @returns {object} Formatter with a .format() method
+ * @throws {Error} If the format name is not registered
+ */
+function getFormatter(name) {
+  const formatter = registry[name];
+  if (!formatter) {
+    throw new Error(`Unknown output format: "${name}". Registered formats: ${Object.keys(registry).join(', ')}`);
+  }
+  return formatter;
+}
+
+/**
+ * Register a custom formatter at runtime.
+ * @param {string} name      - Format name
+ * @param {object} formatter - Object with a .format(measurement, metadata) method
+ */
+function registerFormatter(name, formatter) {
+  if (typeof formatter.format !== 'function') {
+    throw new Error('Formatter must have a .format(measurement, metadata) method');
+  }
+  registry[name] = formatter;
+}
+
+/**
+ * List all registered format names.
+ * @returns {string[]}
+ */
+function getRegisteredFormats() {
+  return Object.keys(registry);
+}
+
+module.exports = { getFormatter, registerFormatter, getRegisteredFormats };

src/helper/formatters/influxdbFormatter.js

@@ -0,0 +1,22 @@
+/**
+ * InfluxDB formatter
+ * Produces the structured object expected by Node-RED InfluxDB nodes:
+ *   { measurement, fields, tags, timestamp }
+ *
+ * @param {string} measurement - The measurement name (e.g. node name)
+ * @param {object} metadata    - { fields, tags }
+ *   - fields: key/value pairs of changed data points
+ *   - tags:   flat key/value string pairs (InfluxDB tags)
+ * @returns {string|object} Formatted payload (object for InfluxDB)
+ */
+function format(measurement, metadata) {
+  const { fields, tags } = metadata;
+  return {
+    measurement: measurement,
+    fields: fields,
+    tags: tags || {},
+    timestamp: new Date(),
+  };
+}
+
+module.exports = { format };

src/helper/formatters/jsonFormatter.js

@@ -0,0 +1,22 @@
+/**
+ * JSON formatter
+ * Produces a JSON string suitable for MQTT, REST APIs, etc.
+ *
+ * @param {string} measurement - The measurement name (e.g. node name)
+ * @param {object} metadata    - { fields, tags }
+ *   - fields: key/value pairs of changed data points
+ *   - tags:   flat key/value string pairs
+ * @returns {string} JSON-encoded string
+ */
+function format(measurement, metadata) {
+  const { fields, tags } = metadata;
+  const payload = {
+    measurement: measurement,
+    fields: fields,
+    tags: tags || {},
+    timestamp: new Date().toISOString(),
+  };
+  return JSON.stringify(payload);
+}
+
+module.exports = { format };

src/helper/formatters/processFormatter.js

@@ -0,0 +1,9 @@
+/**
+ * Process formatter
+ * Keeps the existing process-port behaviour: emit only changed fields as an object.
+ */
+function format(_measurement, metadata) {
+  return metadata.fields;
+}
+
+module.exports = { format };

src/helper/menu/dataFetching.js

@@ -0,0 +1,123 @@
+/**
+ * Data fetching methods for MenuUtils.
+ * Handles primary/fallback URL fetching and API calls.
+ */
+
+const dataFetching = {
+  async fetchData(url, fallbackUrl) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+      const responsData =  await response.json();
+      //responsData
+      const data = responsData.data;
+      /* .map(item => {
+        const { vendor_name, ...rest } = item;
+        return {
+        name: vendor_name,
+        ...rest
+        };
+      }); */
+      console.log(url);
+      console.log("Response Data: ", data);
+      return data;
+
+    } catch (err) {
+      console.warn(
+        `Primary URL failed: ${url}. Trying fallback URL: ${fallbackUrl}`,
+        err
+      );
+      try {
+        const response = await fetch(fallbackUrl);
+        if (!response.ok)
+          throw new Error(`HTTP error! status: ${response.status}`);
+        return await response.json();
+      } catch (fallbackErr) {
+        console.error("Both primary and fallback URLs failed:", fallbackErr);
+        return [];
+      }
+    }
+  },
+
+  async fetchProjectData(url) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+      const responsData =  await response.json();
+      console.log("Response Data: ", responsData);
+      return responsData;
+
+    } catch (err) {
+      /* intentionally empty */
+    }
+  },
+
+  // Save changes to API
+  async apiCall(node) {
+    try{
+        // OLFIANT when a browser refreshes the tag code is lost!!! fix this later!!!!!
+        // FIX UUID ALSO LATER
+
+        if(node.assetTagCode !== "" || node.assetTagCode !== null){ /* intentionally empty */ }
+        // API call to register or check asset in central database
+          let assetregisterAPI = node.configUrls.cloud.taggcodeAPI + "/asset/create_asset.php";
+
+          const assetModelId = node.modelMetadata.id; //asset_product_model_id
+          const uuid = node.uuid; //asset_product_model_uuid
+          const assetName =  node.assetType; //asset_name / type?
+          const description = node.name; // asset_description
+          const assetStatus = "actief"; //asset_status -> koppel aan enable / disable node ? or make dropdown ?
+          const assetProfileId = 1; //asset_profile_id  these are the rules to check if the childs are valid under this node (parent / child id?)
+          const child_assets = ["63247"]; //child_assets tagnummer of id?
+          const assetProcessId = node.processId; //asset_process_id
+          const assetLocationId = node.locationId; //asset_location_id
+          const tagCode = node.assetTagCode; // if already exists in the node information use it to tell the api it exists and it will update else we will get it from the api call
+          //console.log(`this is my tagCode: ${tagCode}`);
+
+          // Build base URL with required parameters
+          let apiUrl = `?asset_product_model_id=${assetModelId}&asset_product_model_uuid=${uuid}&asset_name=${assetName}&asset_description=${description}&asset_status=${assetStatus}&asset_profile_id=${assetProfileId}&asset_location_id=${assetLocationId}&asset_process_id=${assetProcessId}&child_assets=${child_assets}`;
+
+          // Only add tagCode to URL if it exists
+          if (tagCode) {
+              apiUrl += `&asset_tag_number=${tagCode}`;
+              console.log('hello there');
+          }
+
+          assetregisterAPI += apiUrl;
+          console.log("API call to register asset in central database", assetregisterAPI);
+
+          const response = await fetch(assetregisterAPI, {
+              method: "POST"
+          });
+
+          // Get the response text first
+          const responseText = await response.text();
+          console.log("Raw API response:", responseText);
+
+          // Try to parse the JSON, handling potential parsing errors
+          let jsonResponse;
+          try {
+              jsonResponse = JSON.parse(responseText);
+          } catch (parseError) {
+              console.error("JSON Parsing Error:", parseError);
+              console.error("Response that could not be parsed:", responseText);
+              throw new Error("Failed to parse API response");
+          }
+
+          console.log(jsonResponse);
+
+          if(jsonResponse.success){
+              console.log(`${jsonResponse.message}, tag number: ${jsonResponse.asset_tag_number}, asset id: ${jsonResponse.asset_id}`);
+              // Save the asset tag number and id to the node
+          } else {
+              console.log("Asset not registered in central database");
+          }
+          return jsonResponse;
+
+      } catch (error) {
+          console.log("Error saving changes to asset register API", error);
+      }
+  },
+};
+
+module.exports = dataFetching;

src/helper/menu/dropdownPopulation.js

@@ -0,0 +1,283 @@
+/**
+ * Dropdown population methods for MenuUtils.
+ * Handles populating and cascading dropdown menus for assets, suppliers, models, units, etc.
+ */
+
+const dropdownPopulation = {
+  populateSmoothingMethods(configUrls, elements, node) {
+    this.fetchData(configUrls.cloud.config, configUrls.local.config)
+      .then((configData) => {
+        const smoothingMethods =
+          configData.smoothing?.smoothMethod?.rules?.values?.map(
+            (o) => o.value
+          ) || [];
+        this.populateDropdown(
+          elements.smoothMethod,
+          smoothingMethods,
+          node,
+          "smooth_method"
+        );
+      })
+      .catch((err) => {
+        console.error("Error loading smoothing methods", err);
+      });
+  },
+
+  populateInterpolationMethods(configUrls, elements, node) {
+    this.fetchData(configUrls.cloud.config, configUrls.local.config)
+      .then((configData) => {
+        const interpolationMethods =
+          configData?.interpolation?.type?.rules?.values.map((m) => m.value) ||
+          [];
+        this.populateDropdown(
+          elements.interpolationMethodInput,
+          interpolationMethods,
+          node,
+          "interpolationMethod"
+        );
+
+        // Find the selected method and use it to spawn 1 more field to fill in tension
+        //const selectedMethod = interpolationMethods.find(m => m === node.interpolationMethod);
+        this.initTensionToggles(elements, node);
+      })
+      .catch((err) => {
+        console.error("Error loading interpolation methods", err);
+      });
+  },
+
+  populateLogLevelOptions(logLevelSelect, configData, node) {
+    // debug log level
+    //console.log("Displaying configData => ", configData) ;
+
+    const logLevels =
+      configData?.general?.logging?.logLevel?.rules?.values?.map(
+        (l) => l.value
+      ) || [];
+
+    //console.log("Displaying logLevels => ", logLevels);
+
+    // Reuse your existing generic populateDropdown helper
+    this.populateDropdown(logLevelSelect, logLevels, node.logLevel);
+  },
+
+  //cascade dropdowns for asset type, supplier, subType, model, unit
+  fetchAndPopulateDropdowns(configUrls, elements, node) {
+    this.fetchData(configUrls.cloud.config, configUrls.local.config)
+      .then((configData) => {
+        const assetType = configData.asset?.type?.default;
+        const localSuppliersUrl = this.constructUrl(configUrls.local.taggcodeAPI,`${assetType}s`,"suppliers.json");
+        const cloudSuppliersUrl = this.constructCloudURL(configUrls.cloud.taggcodeAPI, "/vendor/get_vendors.php");
+
+        return this.fetchData(cloudSuppliersUrl, localSuppliersUrl)
+          .then((supplierData) => {
+
+            const suppliers = supplierData.map((supplier) => supplier.name);
+
+            // Populate suppliers dropdown and set up its change handler
+            return this.populateDropdown(
+              elements.supplier,
+              suppliers,
+              node,
+              "supplier",
+              function (selectedSupplier) {
+                if (selectedSupplier) {
+                  this.populateSubTypes(configUrls, elements, node, selectedSupplier);
+                }
+              }
+            );
+          })
+          .then(() => {
+            // If we have a saved supplier, trigger subTypes population
+            if (node.supplier) {
+              this.populateSubTypes(configUrls, elements, node, node.supplier);
+            }
+          });
+      })
+      .catch((error) => {
+        console.error("Error in initial dropdown population:", error);
+      });
+  },
+
+  populateSubTypes(configUrls, elements, node, selectedSupplier) {
+
+    this.fetchData(configUrls.cloud.config, configUrls.local.config)
+      .then((configData) => {
+        const assetType = configData.asset?.type?.default;
+        const supplierFolder = this.constructUrl( configUrls.local.taggcodeAPI, `${assetType}s`, selectedSupplier );
+
+        const localSubTypesUrl = this.constructUrl(supplierFolder, "subtypes.json");
+        const cloudSubTypesUrl = this.constructCloudURL(configUrls.cloud.taggcodeAPI, "/product/get_subtypesFromVendor.php?vendor_name=" + selectedSupplier);
+
+        return this.fetchData(cloudSubTypesUrl, localSubTypesUrl)
+          .then((subTypeData) => {
+            const subTypes = subTypeData.map((subType) => subType.name);
+
+            return this.populateDropdown(
+              elements.subType,
+              subTypes,
+              node,
+              "subType",
+              function (selectedSubType) {
+                if (selectedSubType) {
+                  // When subType changes, update both models and units
+                  this.populateModels(
+                    configUrls,
+                    elements,
+                    node,
+                    selectedSupplier,
+                    selectedSubType
+                  );
+                  this.populateUnitsForSubType(
+                    configUrls,
+                    elements,
+                    node,
+                    selectedSubType
+                  );
+                }
+              }
+            );
+          })
+          .then(() => {
+            // If we have a saved subType, trigger both models and units population
+            if (node.subType) {
+              this.populateModels(
+                configUrls,
+                elements,
+                node,
+                selectedSupplier,
+                node.subType
+              );
+              this.populateUnitsForSubType(configUrls, elements, node, node.subType);
+            }
+            //console.log("In fetch part of subtypes ");
+            // Store all data from selected model
+  /*           node["modelMetadata"] = modelData.find(
+              (model) => model.name === node.model
+            );
+            console.log("Model Metadata: ", node["modelMetadata"]); */
+          });
+      })
+      .catch((error) => {
+        console.error("Error populating subtypes:", error);
+      });
+  },
+
+  populateUnitsForSubType(configUrls, elements, node, selectedSubType) {
+    // Fetch the units data
+    this.fetchData(configUrls.cloud.units, configUrls.local.units)
+      .then((unitsData) => {
+        // Find the category that matches the subType name
+        const categoryData = unitsData.units.find(
+          (category) =>
+            category.category.toLowerCase() === selectedSubType.toLowerCase()
+        );
+
+        if (categoryData) {
+          // Extract just the unit values and descriptions
+          const units = categoryData.values.map((unit) => ({
+            value: unit.value,
+            description: unit.description,
+          }));
+
+          // Create the options array with descriptions as labels
+          const options = units.map((unit) => ({
+            value: unit.value,
+            label: `${unit.value} - ${unit.description}`,
+          }));
+
+          // Populate the units dropdown
+          this.populateDropdown(
+            elements.unit,
+            options.map((opt) => opt.value),
+            node,
+            "unit"
+          );
+
+          // If there's no currently selected unit but we have options, select the first one
+          if (!node.unit && options.length > 0) {
+            node.unit = options[0].value;
+            elements.unit.value = options[0].value;
+          }
+        } else {
+          // If no matching category is found, provide a default % option
+          const defaultUnits = [{ value: "%", description: "Percentage" }];
+          this.populateDropdown(
+            elements.unit,
+            defaultUnits.map((unit) => unit.value),
+            node,
+            "unit"
+          );
+          console.warn(
+            `No matching unit category found for subType: ${selectedSubType}`
+          );
+        }
+      })
+      .catch((error) => {
+        console.error("Error fetching units:", error);
+      });
+  },
+
+  populateModels(
+    configUrls,
+    elements,
+    node,
+    selectedSupplier,
+    selectedSubType
+  ) {
+
+    this.fetchData(configUrls.cloud.config, configUrls.local.config)
+      .then((configData) => {
+        const assetType = configData.asset?.type?.default;
+        // save assetType to fetch later
+        node.assetType = assetType;
+
+        const supplierFolder = this.constructUrl( configUrls.local.taggcodeAPI,`${assetType}s`,selectedSupplier);
+        const subTypeFolder = this.constructUrl(supplierFolder, selectedSubType);
+        const localModelsUrl = this.constructUrl(subTypeFolder, "models.json");
+        const cloudModelsUrl  = this.constructCloudURL(configUrls.cloud.taggcodeAPI, "/product/get_product_models.php?vendor_name=" + selectedSupplier + "&product_subtype_name=" + selectedSubType);
+
+        return this.fetchData(cloudModelsUrl, localModelsUrl).then((modelData) => {
+          const models = modelData.map((model) => model.name); // use this to populate the dropdown
+
+          // If a model is already selected, store its metadata immediately
+          if (node.model) {
+            node["modelMetadata"] = modelData.find((model) => model.name === node.model);
+          }
+
+          this.populateDropdown(elements.model, models, node, "model", (selectedModel) => {
+            // Store only the metadata for the selected model
+            node["modelMetadata"] = modelData.find((model) => model.name === selectedModel);
+          });
+          /*
+          console.log('hello here I am:');
+          console.log(node["modelMetadata"]);
+  */
+        });
+
+      })
+      .catch((error) => {
+        console.error("Error populating models:", error);
+      });
+  },
+
+  async populateDropdown(
+    htmlElement,
+    options,
+    node,
+    property,
+    callback
+  ) {
+    this.generateHtml(htmlElement, options, node[property]);
+
+    htmlElement.addEventListener("change", async (e) => {
+      const newValue = e.target.value;
+      console.log(`Dropdown changed: ${property} = ${newValue}`);
+      node[property] = newValue;
+
+      RED.nodes.dirty(true);
+      if (callback) await callback(newValue); // Ensure async callback completion
+    });
+  },
+};
+
+module.exports = dropdownPopulation;

src/helper/menu/htmlGeneration.js

@@ -0,0 +1,151 @@
+/**
+ * HTML generation and endpoint methods for MenuUtils.
+ * Handles generating dropdown HTML and serving MenuUtils code to the browser.
+ */
+
+const htmlGeneration = {
+  generateHtml(htmlElement, options, savedValue) {
+    htmlElement.innerHTML = options.length
+      ? `<option value="">Select...</option>${options
+          .map((opt) => `<option value="${opt}">${opt}</option>`)
+          .join("")}`
+      : "<option value=''>No options available</option>";
+
+    if (savedValue && options.includes(savedValue)) {
+      htmlElement.value = savedValue;
+    }
+  },
+
+  createMenuUtilsEndpoint(RED, nodeName, customHelpers = {}, options = {}) {
+    const basePath = `/${nodeName}/resources`;
+
+    RED.httpAdmin.get(`${basePath}/menuUtilsData.json`, function(req, res) {
+      res.json(this.generateMenuUtilsData(nodeName, customHelpers, options));
+    }.bind(this));
+
+    RED.httpAdmin.get(`${basePath}/menuUtils.legacy.js`, function(req, res) {
+      res.set('Content-Type', 'application/javascript');
+      const browserCode = this.generateLegacyMenuUtilsCode(nodeName, customHelpers);
+      res.send(browserCode);
+    }.bind(this));
+
+    RED.httpAdmin.get(`${basePath}/menuUtils.js`, function(req, res) {
+      res.set('Content-Type', 'application/javascript');
+      res.send(this.generateMenuUtilsBootstrap(nodeName));
+    }.bind(this));
+  },
+
+  generateMenuUtilsData(nodeName, customHelpers = {}, options = {}) {
+    const defaultHelpers = {
+      validateRequired: `function(value) {
+        return value && value.toString().trim() !== '';
+      }`,
+      formatDisplayValue: `function(value, unit) {
+        return \`\${value} \${unit || ''}\`.trim();
+      }`
+    };
+
+    return {
+      nodeName,
+      helpers: { ...defaultHelpers, ...customHelpers },
+      options: {
+        autoLoadLegacy: options.autoLoadLegacy !== false,
+      },
+    };
+  },
+
+  generateMenuUtilsBootstrap(nodeName) {
+    return `
+    // Stable bootstrap for EVOLV menu utils (${nodeName})
+    (function() {
+      const nodeName = ${JSON.stringify(nodeName)};
+      const basePath = '/' + nodeName + '/resources';
+
+      window.EVOLV = window.EVOLV || {};
+      window.EVOLV.nodes = window.EVOLV.nodes || {};
+      window.EVOLV.nodes[nodeName] = window.EVOLV.nodes[nodeName] || {};
+      window.EVOLV.nodes[nodeName].utils = window.EVOLV.nodes[nodeName].utils || {};
+
+      function parseHelper(fnBody) {
+        try {
+          return (new Function('return (' + fnBody + ')'))();
+        } catch (error) {
+          console.error('[menuUtils] helper parse failed:', error);
+          return function() { return null; };
+        }
+      }
+
+      function loadLegacyIfNeeded(autoLoadLegacy) {
+        if (!autoLoadLegacy || typeof window.MenuUtils === 'function') return Promise.resolve();
+        return new Promise((resolve, reject) => {
+          const script = document.createElement('script');
+          script.src = basePath + '/menuUtils.legacy.js';
+          script.onload = resolve;
+          script.onerror = reject;
+          document.head.appendChild(script);
+        });
+      }
+
+      fetch(basePath + '/menuUtilsData.json')
+        .then(function(res) { return res.json(); })
+        .then(function(payload) {
+          const helperFns = {};
+          Object.entries(payload.helpers || {}).forEach(function(entry) {
+            helperFns[entry[0]] = parseHelper(entry[1]);
+          });
+          window.EVOLV.nodes[nodeName].utils.helpers = helperFns;
+          return loadLegacyIfNeeded(payload.options && payload.options.autoLoadLegacy);
+        })
+        .then(function() {
+          if (typeof window.MenuUtils === 'function' && !window.EVOLV.nodes[nodeName].utils.menuUtils) {
+            window.EVOLV.nodes[nodeName].utils.menuUtils = new window.MenuUtils();
+          }
+        })
+        .catch(function(error) {
+          console.error('[menuUtils] bootstrap failed for ' + nodeName, error);
+        });
+    })();
+    `;
+  },
+
+  generateLegacyMenuUtilsCode(nodeName, customHelpers = {}) {
+    const allHelpers = { ...this.generateMenuUtilsData(nodeName).helpers, ...customHelpers };
+
+    const helpersCode = Object.entries(allHelpers)
+      .map(([name, func]) => `        ${name}: ${func}`)
+      .join(',\n');
+
+    const classCode = this.constructor.toString(); // <-- this gives full class MenuUtils {...}
+
+    return `
+      // Create EVOLV namespace structure
+      window.EVOLV = window.EVOLV || {};
+      window.EVOLV.nodes = window.EVOLV.nodes || {};
+      window.EVOLV.nodes.${nodeName} = window.EVOLV.nodes.${nodeName} || {};
+
+      // Inject MenuUtils class
+      ${classCode}
+
+      // Expose MenuUtils instance to namespace
+      window.EVOLV.nodes.${nodeName}.utils = {
+        menuUtils: new MenuUtils(),
+
+        helpers: {
+${helpersCode}
+        }
+      };
+
+      // Optionally expose globally
+      window.MenuUtils = MenuUtils;
+
+      console.log('${nodeName} utilities loaded in namespace');
+    `;
+  },
+
+  // Backward-compatible alias
+  generateMenuUtilsCode(nodeName, customHelpers = {}) {
+    return this.generateLegacyMenuUtilsCode(nodeName, customHelpers);
+  },
+};
+
+module.exports = htmlGeneration;

src/helper/menu/index.js

@@ -0,0 +1,18 @@
+/**
+ * menu/index.js
+ * Barrel file for the menu module components.
+ */
+
+const toggles = require('./toggles');
+const dataFetching = require('./dataFetching');
+const urlUtils = require('./urlUtils');
+const dropdownPopulation = require('./dropdownPopulation');
+const htmlGeneration = require('./htmlGeneration');
+
+module.exports = {
+  toggles,
+  dataFetching,
+  urlUtils,
+  dropdownPopulation,
+  htmlGeneration,
+};

src/helper/menu/toggles.js

@@ -0,0 +1,56 @@
+/**
+ * Toggle initialization methods for MenuUtils.
+ * Controls visibility of UI elements based on checkbox/dropdown state.
+ */
+
+const toggles = {
+  initBasicToggles(elements) {
+    // Toggle visibility for log level
+    elements.logCheckbox.addEventListener("change", function () {
+      elements.rowLogLevel.style.display = this.checked ? "block" : "none";
+    });
+    elements.rowLogLevel.style.display = elements.logCheckbox.checked
+      ? "block"
+      : "none";
+  },
+
+  // Define the initialize toggles function within scope
+  initMeasurementToggles(elements) {
+    // Toggle visibility for scaling inputs
+    elements.scalingCheckbox.addEventListener("change", function () {
+      elements.rowInputMin.style.display = this.checked ? "block" : "none";
+      elements.rowInputMax.style.display = this.checked ? "block" : "none";
+    });
+
+    // Set initial states
+    elements.rowInputMin.style.display = elements.scalingCheckbox.checked
+      ? "block"
+      : "none";
+    elements.rowInputMax.style.display = elements.scalingCheckbox.checked
+      ? "block"
+      : "none";
+  },
+
+  initTensionToggles(elements, node) {
+    const currentMethod = node.interpolationMethod;
+    elements.rowTension.style.display =
+      currentMethod === "monotone_cubic_spline" ? "block" : "none";
+    console.log(
+      "Initial tension row display: ",
+      elements.rowTension.style.display
+    );
+
+    elements.interpolationMethodInput.addEventListener("change", function () {
+      const selectedMethod = this.value;
+      console.log(`Interpolation method changed: ${selectedMethod}`);
+      node.interpolationMethod = selectedMethod;
+
+      // Toggle visibility for tension input
+      elements.rowTension.style.display =
+        selectedMethod === "monotone_cubic_spline" ? "block" : "none";
+      console.log("Tension row display: ", elements.rowTension.style.display);
+    });
+  },
+};
+
+module.exports = toggles;

src/helper/menu/urlUtils.js

@@ -0,0 +1,39 @@
+/**
+ * URL construction methods for MenuUtils.
+ * Helpers for building API and config URLs.
+ */
+
+const urlUtils = {
+  getSpecificConfigUrl(nodeName, cloudAPI) {
+    const cloudConfigURL = cloudAPI + "/config/" + nodeName + ".json";
+    const localConfigURL = "http://localhost:1880/"+ nodeName + "/dependencies/"+ nodeName + "/" + nodeName + "Config.json";
+
+    return { cloudConfigURL, localConfigURL };
+  },
+
+  // Helper function to construct a URL from a base and path internal
+  constructUrl(base, ...paths) {
+    // Remove trailing slash from base and leading slashes from paths
+    const sanitizedBase = (base || "").replace(/\/+$/, "");
+    const sanitizedPaths = paths.map((path) => path.replace(/^\/+|\/+$/g, ""));
+
+    // Join sanitized base and paths
+    const url = `${sanitizedBase}/${sanitizedPaths.join("/")}`;
+    console.log("Base:", sanitizedBase);
+    console.log("Paths:", sanitizedPaths);
+    console.log("Constructed URL:", url);
+    return url;
+  },
+
+  //Adjust for API Gateway
+  constructCloudURL(base, ...paths) {
+    // Remove trailing slash from base and leading slashes from paths
+    const sanitizedBase = base.replace(/\/+$/, "");
+    const sanitizedPaths = paths.map((path) => path.replace(/^\/+|\/+$/g, ""));
+    // Join sanitized base and paths
+    const url = `${sanitizedBase}/${sanitizedPaths.join("/")}`;
+    return url;
+  },
+};
+
+module.exports = urlUtils;

src/helper/menuUtils.js

@@ -1,616 +1,34 @@
+/**
+ * MenuUtils — UI menu helper for Node-RED editor.
+ * Methods are split across focused modules under ./menu/ and mixed onto the prototype.
+ */
+
+const toggles = require('./menu/toggles');
+const dataFetching = require('./menu/dataFetching');
+const urlUtils = require('./menu/urlUtils');
+const dropdownPopulation = require('./menu/dropdownPopulation');
+const htmlGeneration = require('./menu/htmlGeneration');
+
 class MenuUtils {
-  
-
-initBasicToggles(elements) {
-  // Toggle visibility for log level
-  elements.logCheckbox.addEventListener("change", function () {
-    elements.rowLogLevel.style.display = this.checked ? "block" : "none";
-  });
-  elements.rowLogLevel.style.display = elements.logCheckbox.checked
-    ? "block"
-    : "none";
-}
-
-// Define the initialize toggles function within scope
-initMeasurementToggles(elements) {
-  // Toggle visibility for scaling inputs
-  elements.scalingCheckbox.addEventListener("change", function () {
-    elements.rowInputMin.style.display = this.checked ? "block" : "none";
-    elements.rowInputMax.style.display = this.checked ? "block" : "none";
-  });
-
-  // Set initial states
-  elements.rowInputMin.style.display = elements.scalingCheckbox.checked
-    ? "block"
-    : "none";
-  elements.rowInputMax.style.display = elements.scalingCheckbox.checked
-    ? "block"
-    : "none";
-}
-
-initTensionToggles(elements, node) {
-  const currentMethod = node.interpolationMethod;
-  elements.rowTension.style.display =
-    currentMethod === "monotone_cubic_spline" ? "block" : "none";
-  console.log(
-    "Initial tension row display: ",
-    elements.rowTension.style.display
-  );
-
-  elements.interpolationMethodInput.addEventListener("change", function () {
-    const selectedMethod = this.value;
-    console.log(`Interpolation method changed: ${selectedMethod}`);
-    node.interpolationMethod = selectedMethod;
-
-    // Toggle visibility for tension input
-    elements.rowTension.style.display =
-      selectedMethod === "monotone_cubic_spline" ? "block" : "none";
-    console.log("Tension row display: ", elements.rowTension.style.display);
-  });
-}
-// Define the smoothing methods population function within scope
-populateSmoothingMethods(configUrls, elements, node) {
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const smoothingMethods =
-        configData.smoothing?.smoothMethod?.rules?.values?.map(
-          (o) => o.value
-        ) || [];
-      this.populateDropdown(
-        elements.smoothMethod,
-        smoothingMethods,
-        node,
-        "smooth_method"
-      );
-    })
-    .catch((err) => {
-      console.error("Error loading smoothing methods", err);
-    });
-}
-
-populateInterpolationMethods(configUrls, elements, node) {
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const interpolationMethods =
-        configData?.interpolation?.type?.rules?.values.map((m) => m.value) ||
-        [];
-      this.populateDropdown(
-        elements.interpolationMethodInput,
-        interpolationMethods,
-        node,
-        "interpolationMethod"
-      );
-
-      // Find the selected method and use it to spawn 1 more field to fill in tension
-      //const selectedMethod = interpolationMethods.find(m => m === node.interpolationMethod);
-      this.initTensionToggles(elements, node);
-    })
-    .catch((err) => {
-      console.error("Error loading interpolation methods", err);
-    });
-}
-
-populateLogLevelOptions(logLevelSelect, configData, node) {
-  // debug log level
-  //console.log("Displaying configData => ", configData) ;
-
-  const logLevels =
-    configData?.general?.logging?.logLevel?.rules?.values?.map(
-      (l) => l.value
-    ) || [];
-
-  //console.log("Displaying logLevels => ", logLevels);
-
-  // Reuse your existing generic populateDropdown helper
-  this.populateDropdown(logLevelSelect, logLevels, node.logLevel);
-}
-
-//cascade dropdowns for asset type, supplier, subType, model, unit
-fetchAndPopulateDropdowns(configUrls, elements, node) {
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const assetType = configData.asset?.type?.default;
-      const localSuppliersUrl = this.constructUrl(configUrls.local.taggcodeAPI,`${assetType}s`,"suppliers.json");
-      const cloudSuppliersUrl = this.constructCloudURL(configUrls.cloud.taggcodeAPI, "/vendor/get_vendors.php");
-
-      return this.fetchData(cloudSuppliersUrl, localSuppliersUrl)
-        .then((supplierData) => {
-
-          const suppliers = supplierData.map((supplier) => supplier.name);
-        
-          // Populate suppliers dropdown and set up its change handler
-          return this.populateDropdown(
-            elements.supplier,
-            suppliers,
-            node,
-            "supplier",
-            function (selectedSupplier) {
-              if (selectedSupplier) {
-                this.populateSubTypes(configUrls, elements, node, selectedSupplier);
-              }
-            }
-          );
-        })
-        .then(() => {
-          // If we have a saved supplier, trigger subTypes population
-          if (node.supplier) {
-            this.populateSubTypes(configUrls, elements, node, node.supplier);
-          }
-        });
-    })
-    .catch((error) => {
-      console.error("Error in initial dropdown population:", error);
-    });
-}
-
-getSpecificConfigUrl(nodeName,cloudAPI) {
-    
-      const cloudConfigURL = cloudAPI + "/config/" + nodeName + ".json";
-      const localConfigURL = "http://localhost:1880/"+ nodeName + "/dependencies/"+ nodeName + "/" + nodeName + "Config.json";
-        
-      return { cloudConfigURL, localConfigURL };
-    
-}
-
-// Save changes to API
-async apiCall(node) {
-  try{
-      // OLFIANT when a browser refreshes the tag code is lost!!! fix this later!!!!!
-      // FIX UUID ALSO LATER 
-
-      if(node.assetTagCode !== "" || node.assetTagCode !== null){ }
-      // API call to register or check asset in central database
-        let assetregisterAPI = node.configUrls.cloud.taggcodeAPI + "/asset/create_asset.php";
-
-        const assetModelId = node.modelMetadata.id; //asset_product_model_id
-        const uuid = node.uuid; //asset_product_model_uuid
-        const assetName =  node.assetType; //asset_name / type?
-        const description = node.name; // asset_description
-        const assetStatus = "actief"; //asset_status -> koppel aan enable / disable node ? or make dropdown ?
-        const assetProfileId = 1; //asset_profile_id  these are the rules to check if the childs are valid under this node (parent / child id?)
-        const child_assets = ["63247"]; //child_assets tagnummer of id?
-        const assetProcessId = node.processId; //asset_process_id
-        const assetLocationId = node.locationId; //asset_location_id
-        const tagCode = node.assetTagCode; // if already exists in the node information use it to tell the api it exists and it will update else we will get it from the api call
-        //console.log(`this is my tagCode: ${tagCode}`);
-
-        // Build base URL with required parameters
-        let apiUrl = `?asset_product_model_id=${assetModelId}&asset_product_model_uuid=${uuid}&asset_name=${assetName}&asset_description=${description}&asset_status=${assetStatus}&asset_profile_id=${assetProfileId}&asset_location_id=${assetLocationId}&asset_process_id=${assetProcessId}&child_assets=${child_assets}`;
-        
-        // Only add tagCode to URL if it exists
-        if (tagCode) {
-            apiUrl += `&asset_tag_number=${tagCode}`;
-        }
-
-        assetregisterAPI += apiUrl;
-        console.log("API call to register asset in central database", assetregisterAPI);
-
-        const response = await fetch(assetregisterAPI, {
-            method: "POST"
-        });
-
-        // Get the response text first
-        const responseText = await response.text();
-        console.log("Raw API response:", responseText);
-
-        // Try to parse the JSON, handling potential parsing errors
-        let jsonResponse;
-        try {
-            jsonResponse = JSON.parse(responseText);
-        } catch (parseError) {
-            console.error("JSON Parsing Error:", parseError);
-            console.error("Response that could not be parsed:", responseText);
-            throw new Error("Failed to parse API response");
-        }
-
-        console.log(jsonResponse);
-
-        if(jsonResponse.success){
-            console.log(`${jsonResponse.message}, tag number: ${jsonResponse.asset_tag_number}, asset id: ${jsonResponse.asset_id}`);
-            // Save the asset tag number and id to the node
-        } else {
-            console.log("Asset not registered in central database");
-        }
-        return jsonResponse;
-
-    } catch (error) {
-        console.log("Error saving changes to asset register API", error);
-    }
-}
-
-
-async fetchData(url, fallbackUrl) {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-    const responsData =  await response.json();
-    //responsData
-    const data = responsData.data;
-    /* .map(item => {
-      const { vendor_name, ...rest } = item;
-      return {
-      name: vendor_name,
-      ...rest
-      };
-    }); */
-    console.log(url);
-    console.log("Response Data: ", data);
-    return data;
-
-  } catch (err) {
-    console.warn(
-      `Primary URL failed: ${url}. Trying fallback URL: ${fallbackUrl}`,
-      err
-    );
-    try {
-      const response = await fetch(fallbackUrl);
-      if (!response.ok)
-        throw new Error(`HTTP error! status: ${response.status}`);
-      return await response.json();
-    } catch (fallbackErr) {
-      console.error("Both primary and fallback URLs failed:", fallbackErr);
-      return [];
-    }
+  constructor() {
+    this.isCloud = false;
+    this.configData = null;
   }
 }
 
-async fetchProjectData(url) {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-    const responsData =  await response.json();
-    console.log("Response Data: ", responsData);
-    return responsData;
-
-  } catch (err) {
-  }
-}
-
-async populateDropdown(
-  htmlElement,
-  options,
-  node,
-  property,
-  callback
-) {
-  this.generateHtml(htmlElement, options, node[property]);
-
-  htmlElement.addEventListener("change", async (e) => {
-    const newValue = e.target.value;
-    console.log(`Dropdown changed: ${property} = ${newValue}`);
-    node[property] = newValue;
-
-    RED.nodes.dirty(true);
-    if (callback) await callback(newValue); // Ensure async callback completion
-  });
-}
-
-// Helper function to construct a URL from a base and path internal
-constructUrl(base, ...paths) {
-
-  // Remove trailing slash from base and leading slashes from paths
-  const sanitizedBase = (base || "").replace(/\/+$/, "");
-  const sanitizedPaths = paths.map((path) => path.replace(/^\/+|\/+$/g, ""));
-
-  // Join sanitized base and paths
-  const url = `${sanitizedBase}/${sanitizedPaths.join("/")}`;
-  console.log("Base:", sanitizedBase);
-  console.log("Paths:", sanitizedPaths);
-  console.log("Constructed URL:", url);
-  return url;
-}
-
-//Adjust for API Gateway
-constructCloudURL(base, ...paths) {
-  // Remove trailing slash from base and leading slashes from paths
-  const sanitizedBase = base.replace(/\/+$/, "");
-  const sanitizedPaths = paths.map((path) => path.replace(/^\/+|\/+$/g, ""));
-  // Join sanitized base and paths
-  const url = `${sanitizedBase}/${sanitizedPaths.join("/")}`;
-  return url;
-}
-
-populateSubTypes(configUrls, elements, node, selectedSupplier) {
-
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const assetType = configData.asset?.type?.default;
-      const supplierFolder = this.constructUrl( configUrls.local.taggcodeAPI, `${assetType}s`, selectedSupplier );
-
-      const localSubTypesUrl = this.constructUrl(supplierFolder, "subtypes.json");
-      const cloudSubTypesUrl = this.constructCloudURL(configUrls.cloud.taggcodeAPI, "/product/get_subtypesFromVendor.php?vendor_name=" + selectedSupplier);
-
-      return this.fetchData(cloudSubTypesUrl, localSubTypesUrl)
-        .then((subTypeData) => {
-          const subTypes = subTypeData.map((subType) => subType.name);
-
-          return this.populateDropdown(
-            elements.subType,
-            subTypes,
-            node,
-            "subType",
-            function (selectedSubType) {
-              if (selectedSubType) {
-                // When subType changes, update both models and units
-                this.populateModels(
-                  configUrls,
-                  elements,
-                  node,
-                  selectedSupplier,
-                  selectedSubType
-                );
-                this.populateUnitsForSubType(
-                  configUrls,
-                  elements,
-                  node,
-                  selectedSubType
-                );
-              }
-            }
-          );
-        })
-        .then(() => {
-          // If we have a saved subType, trigger both models and units population
-          if (node.subType) {
-            this.populateModels(
-              configUrls,
-              elements,
-              node,
-              selectedSupplier,
-              node.subType
-            );
-            this.populateUnitsForSubType(configUrls, elements, node, node.subType);
-          }
-          //console.log("In fetch part of subtypes ");
-          // Store all data from selected model
-/*           node["modelMetadata"] = modelData.find(
-            (model) => model.name === node.model
-          );
-          console.log("Model Metadata: ", node["modelMetadata"]); */
-        });
-    })
-    .catch((error) => {
-      console.error("Error populating subtypes:", error);
-    });
-}
-
-populateUnitsForSubType(configUrls, elements, node, selectedSubType) {
-  // Fetch the units data
-  this.fetchData(configUrls.cloud.units, configUrls.local.units)
-    .then((unitsData) => {
-      // Find the category that matches the subType name
-      const categoryData = unitsData.units.find(
-        (category) =>
-          category.category.toLowerCase() === selectedSubType.toLowerCase()
-      );
-
-      if (categoryData) {
-        // Extract just the unit values and descriptions
-        const units = categoryData.values.map((unit) => ({
-          value: unit.value,
-          description: unit.description,
-        }));
-
-        // Create the options array with descriptions as labels
-        const options = units.map((unit) => ({
-          value: unit.value,
-          label: `${unit.value} - ${unit.description}`,
-        }));
-
-        // Populate the units dropdown
-        this.populateDropdown(
-          elements.unit,
-          options.map((opt) => opt.value),
-          node,
-          "unit"
-        );
-
-        // If there's no currently selected unit but we have options, select the first one
-        if (!node.unit && options.length > 0) {
-          node.unit = options[0].value;
-          elements.unit.value = options[0].value;
-        }
-      } else {
-        // If no matching category is found, provide a default % option
-        const defaultUnits = [{ value: "%", description: "Percentage" }];
-        this.populateDropdown(
-          elements.unit,
-          defaultUnits.map((unit) => unit.value),
-          node,
-          "unit"
-        );
-        console.warn(
-          `No matching unit category found for subType: ${selectedSubType}`
-        );
-      }
-    })
-    .catch((error) => {
-      console.error("Error fetching units:", error);
-    });
-}
-
-populateModels(
-  configUrls,
-  elements,
-  node,
-  selectedSupplier,
-  selectedSubType
-) {
-
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const assetType = configData.asset?.type?.default;
-      // save assetType to fetch later 
-      node.assetType = assetType;
-
-      const supplierFolder = this.constructUrl( configUrls.local.taggcodeAPI,`${assetType}s`,selectedSupplier);
-      const subTypeFolder = this.constructUrl(supplierFolder, selectedSubType);
-      const localModelsUrl = this.constructUrl(subTypeFolder, "models.json");
-      const cloudModelsUrl  = this.constructCloudURL(configUrls.cloud.taggcodeAPI, "/product/get_product_models.php?vendor_name=" + selectedSupplier + "&product_subtype_name=" + selectedSubType);
-
-      return this.fetchData(cloudModelsUrl, localModelsUrl).then((modelData) => {
-        const models = modelData.map((model) => model.name); // use this to populate the dropdown
-
-        // If a model is already selected, store its metadata immediately
-        if (node.model) {
-          node["modelMetadata"] = modelData.find((model) => model.name === node.model);
-        }
-
-        this.populateDropdown(elements.model, models, node, "model", (selectedModel) => {
-          // Store only the metadata for the selected model
-          node["modelMetadata"] = modelData.find((model) => model.name === selectedModel);
-        });
+// Mix all method groups onto the prototype
+const mixins = [toggles, dataFetching, urlUtils, dropdownPopulation, htmlGeneration];
+for (const mixin of mixins) {
+  for (const [name, fn] of Object.entries(mixin)) {
+    if (typeof fn === 'function') {
+      Object.defineProperty(MenuUtils.prototype, name, {
+        value: fn,
+        writable: true,
+        configurable: true,
+        enumerable: false,
       });
-
-    })
-    .catch((error) => {
-      console.error("Error populating models:", error);
-    });
-}
-
-generateHtml(htmlElement, options, savedValue) {
-  htmlElement.innerHTML = options.length
-    ? `<option value="">Select...</option>${options
-        .map((opt) => `<option value="${opt}">${opt}</option>`)
-        .join("")}`
-    : "<option value=''>No options available</option>";
-
-  if (savedValue && options.includes(savedValue)) {
-    htmlElement.value = savedValue;
+    }
   }
 }
 
-createMenuUtilsEndpoint(RED, nodeName, customHelpers = {}, options = {}) {
-    const basePath = `/${nodeName}/resources`;
-
-    RED.httpAdmin.get(`${basePath}/menuUtilsData.json`, function(req, res) {
-      res.json(this.generateMenuUtilsData(nodeName, customHelpers, options));
-    }.bind(this));
-
-    RED.httpAdmin.get(`${basePath}/menuUtils.legacy.js`, function(req, res) {
-      res.set('Content-Type', 'application/javascript');
-      const browserCode = this.generateLegacyMenuUtilsCode(nodeName, customHelpers);
-      res.send(browserCode);
-    }.bind(this));
-
-    RED.httpAdmin.get(`${basePath}/menuUtils.js`, function(req, res) {
-      res.set('Content-Type', 'application/javascript');
-      res.send(this.generateMenuUtilsBootstrap(nodeName));
-    }.bind(this));
-  }
-
-generateMenuUtilsData(nodeName, customHelpers = {}, options = {}) {
-  const defaultHelpers = {
-    validateRequired: `function(value) {
-      return value && value.toString().trim() !== '';
-    }`,
-    formatDisplayValue: `function(value, unit) {
-      return \`\${value} \${unit || ''}\`.trim();
-    }`
-  };
-
-  return {
-    nodeName,
-    helpers: { ...defaultHelpers, ...customHelpers },
-    options: {
-      autoLoadLegacy: options.autoLoadLegacy !== false,
-    },
-  };
-}
-
-generateMenuUtilsBootstrap(nodeName) {
-  return `
-    // Stable bootstrap for EVOLV menu utils (${nodeName})
-    (function() {
-      const nodeName = ${JSON.stringify(nodeName)};
-      const basePath = '/' + nodeName + '/resources';
-
-      window.EVOLV = window.EVOLV || {};
-      window.EVOLV.nodes = window.EVOLV.nodes || {};
-      window.EVOLV.nodes[nodeName] = window.EVOLV.nodes[nodeName] || {};
-      window.EVOLV.nodes[nodeName].utils = window.EVOLV.nodes[nodeName].utils || {};
-
-      function parseHelper(fnBody) {
-        try {
-          return (new Function('return (' + fnBody + ')'))();
-        } catch (error) {
-          console.error('[menuUtils] helper parse failed:', error);
-          return function() { return null; };
-        }
-      }
-
-      function loadLegacyIfNeeded(autoLoadLegacy) {
-        if (!autoLoadLegacy || typeof window.MenuUtils === 'function') return Promise.resolve();
-        return new Promise((resolve, reject) => {
-          const script = document.createElement('script');
-          script.src = basePath + '/menuUtils.legacy.js';
-          script.onload = resolve;
-          script.onerror = reject;
-          document.head.appendChild(script);
-        });
-      }
-
-      fetch(basePath + '/menuUtilsData.json')
-        .then(function(res) { return res.json(); })
-        .then(function(payload) {
-          const helperFns = {};
-          Object.entries(payload.helpers || {}).forEach(function(entry) {
-            helperFns[entry[0]] = parseHelper(entry[1]);
-          });
-          window.EVOLV.nodes[nodeName].utils.helpers = helperFns;
-          return loadLegacyIfNeeded(payload.options && payload.options.autoLoadLegacy);
-        })
-        .then(function() {
-          if (typeof window.MenuUtils === 'function' && !window.EVOLV.nodes[nodeName].utils.menuUtils) {
-            window.EVOLV.nodes[nodeName].utils.menuUtils = new window.MenuUtils();
-          }
-        })
-        .catch(function(error) {
-          console.error('[menuUtils] bootstrap failed for ' + nodeName, error);
-        });
-    })();
-  `;
-}
-
-generateLegacyMenuUtilsCode(nodeName, customHelpers = {}) {
-  const allHelpers = { ...this.generateMenuUtilsData(nodeName).helpers, ...customHelpers };
-
-  const helpersCode = Object.entries(allHelpers)
-    .map(([name, func]) => `        ${name}: ${func}`)
-    .join(',\n');
-
-  const classCode = MenuUtils.toString(); // <-- this gives full class MenuUtils {...}
-
-  return `
-    // Create EVOLV namespace structure
-    window.EVOLV = window.EVOLV || {};
-    window.EVOLV.nodes = window.EVOLV.nodes || {};
-    window.EVOLV.nodes.${nodeName} = window.EVOLV.nodes.${nodeName} || {};
-
-    // Inject MenuUtils class
-    ${classCode}
-
-    // Expose MenuUtils instance to namespace
-    window.EVOLV.nodes.${nodeName}.utils = {
-      menuUtils: new MenuUtils(),
-
-      helpers: {
-${helpersCode}
-      }
-    };
-
-    // Optionally expose globally
-    window.MenuUtils = MenuUtils;
-
-    console.log('${nodeName} utilities loaded in namespace');
-  `;
-}
-
-// Backward-compatible alias
-generateMenuUtilsCode(nodeName, customHelpers = {}) {
-  return this.generateLegacyMenuUtilsCode(nodeName, customHelpers);
-}
-
-}
-
 module.exports = MenuUtils;

src/helper/menuUtils_DEPRECATED.js

@@ -1,539 +0,0 @@
-class MenuUtils {
-  
-
-initBasicToggles(elements) {
-  // Toggle visibility for log level
-  elements.logCheckbox.addEventListener("change", function () {
-    elements.rowLogLevel.style.display = this.checked ? "block" : "none";
-  });
-  elements.rowLogLevel.style.display = elements.logCheckbox.checked
-    ? "block"
-    : "none";
-}
-
-// Define the initialize toggles function within scope
-initMeasurementToggles(elements) {
-  // Toggle visibility for scaling inputs
-  elements.scalingCheckbox.addEventListener("change", function () {
-    elements.rowInputMin.style.display = this.checked ? "block" : "none";
-    elements.rowInputMax.style.display = this.checked ? "block" : "none";
-  });
-
-  // Set initial states
-  elements.rowInputMin.style.display = elements.scalingCheckbox.checked
-    ? "block"
-    : "none";
-  elements.rowInputMax.style.display = elements.scalingCheckbox.checked
-    ? "block"
-    : "none";
-}
-
-initTensionToggles(elements, node) {
-  const currentMethod = node.interpolationMethod;
-  elements.rowTension.style.display =
-    currentMethod === "monotone_cubic_spline" ? "block" : "none";
-  console.log(
-    "Initial tension row display: ",
-    elements.rowTension.style.display
-  );
-
-  elements.interpolationMethodInput.addEventListener("change", function () {
-    const selectedMethod = this.value;
-    console.log(`Interpolation method changed: ${selectedMethod}`);
-    node.interpolationMethod = selectedMethod;
-
-    // Toggle visibility for tension input
-    elements.rowTension.style.display =
-      selectedMethod === "monotone_cubic_spline" ? "block" : "none";
-    console.log("Tension row display: ", elements.rowTension.style.display);
-  });
-}
-// Define the smoothing methods population function within scope
-populateSmoothingMethods(configUrls, elements, node) {
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const smoothingMethods =
-        configData.smoothing?.smoothMethod?.rules?.values?.map(
-          (o) => o.value
-        ) || [];
-      this.populateDropdown(
-        elements.smoothMethod,
-        smoothingMethods,
-        node,
-        "smooth_method"
-      );
-    })
-    .catch((err) => {
-      console.error("Error loading smoothing methods", err);
-    });
-}
-
-populateInterpolationMethods(configUrls, elements, node) {
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const interpolationMethods =
-        configData?.interpolation?.type?.rules?.values.map((m) => m.value) ||
-        [];
-      this.populateDropdown(
-        elements.interpolationMethodInput,
-        interpolationMethods,
-        node,
-        "interpolationMethod"
-      );
-
-      // Find the selected method and use it to spawn 1 more field to fill in tension
-      //const selectedMethod = interpolationMethods.find(m => m === node.interpolationMethod);
-      this.initTensionToggles(elements, node);
-    })
-    .catch((err) => {
-      console.error("Error loading interpolation methods", err);
-    });
-}
-
-populateLogLevelOptions(logLevelSelect, configData, node) {
-  // debug log level
-  //console.log("Displaying configData => ", configData) ;
-
-  const logLevels =
-    configData?.general?.logging?.logLevel?.rules?.values?.map(
-      (l) => l.value
-    ) || [];
-
-  //console.log("Displaying logLevels => ", logLevels);
-
-  // Reuse your existing generic populateDropdown helper
-  this.populateDropdown(logLevelSelect, logLevels, node.logLevel);
-}
-
-//cascade dropdowns for asset type, supplier, subType, model, unit
-fetchAndPopulateDropdowns(configUrls, elements, node) {
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const assetType = configData.asset?.type?.default;
-      const localSuppliersUrl = this.constructUrl(configUrls.local.taggcodeAPI,`${assetType}s`,"suppliers.json");
-      const cloudSuppliersUrl = this.constructCloudURL(configUrls.cloud.taggcodeAPI, "/vendor/get_vendors.php");
-
-      return this.fetchData(cloudSuppliersUrl, localSuppliersUrl)
-        .then((supplierData) => {
-
-          const suppliers = supplierData.map((supplier) => supplier.name);
-        
-          // Populate suppliers dropdown and set up its change handler
-          return this.populateDropdown(
-            elements.supplier,
-            suppliers,
-            node,
-            "supplier",
-            function (selectedSupplier) {
-              if (selectedSupplier) {
-                this.populateSubTypes(configUrls, elements, node, selectedSupplier);
-              }
-            }
-          );
-        })
-        .then(() => {
-          // If we have a saved supplier, trigger subTypes population
-          if (node.supplier) {
-            this.populateSubTypes(configUrls, elements, node, node.supplier);
-          }
-        });
-    })
-    .catch((error) => {
-      console.error("Error in initial dropdown population:", error);
-    });
-}
-
-getSpecificConfigUrl(nodeName,cloudAPI) {
-    
-      const cloudConfigURL = cloudAPI + "/config/" + nodeName + ".json";
-      const localConfigURL = "http://localhost:1880/"+ nodeName + "/dependencies/"+ nodeName + "/" + nodeName + "Config.json";
-        
-      return { cloudConfigURL, localConfigURL };
-    
-}
-
-// Save changes to API
-async apiCall(node) {
-  try{
-      // OLFIANT when a browser refreshes the tag code is lost!!! fix this later!!!!!
-      // FIX UUID ALSO LATER 
-
-      if(node.assetTagCode !== "" || node.assetTagCode !== null){ }
-      // API call to register or check asset in central database
-        let assetregisterAPI = node.configUrls.cloud.taggcodeAPI + "/asset/create_asset.php";
-
-        const assetModelId = node.modelMetadata.id; //asset_product_model_id
-        const uuid = node.uuid; //asset_product_model_uuid
-        const assetName =  node.assetType; //asset_name / type?
-        const description = node.name; // asset_description
-        const assetStatus = "actief"; //asset_status -> koppel aan enable / disable node ? or make dropdown ?
-        const assetProfileId = 1; //asset_profile_id  these are the rules to check if the childs are valid under this node (parent / child id?)
-        const child_assets = ["63247"]; //child_assets tagnummer of id?
-        const assetProcessId = node.processId; //asset_process_id
-        const assetLocationId = node.locationId; //asset_location_id
-        const tagCode = node.assetTagCode; // if already exists in the node information use it to tell the api it exists and it will update else we will get it from the api call
-        //console.log(`this is my tagCode: ${tagCode}`);
-
-        // Build base URL with required parameters
-        let apiUrl = `?asset_product_model_id=${assetModelId}&asset_product_model_uuid=${uuid}&asset_name=${assetName}&asset_description=${description}&asset_status=${assetStatus}&asset_profile_id=${assetProfileId}&asset_location_id=${assetLocationId}&asset_process_id=${assetProcessId}&child_assets=${child_assets}`;
-        
-        // Only add tagCode to URL if it exists
-        if (tagCode) {
-            apiUrl += `&asset_tag_number=${tagCode}`;
-        }
-
-        assetregisterAPI += apiUrl;
-        console.log("API call to register asset in central database", assetregisterAPI);
-
-        const response = await fetch(assetregisterAPI, {
-            method: "POST"
-        });
-
-        // Get the response text first
-        const responseText = await response.text();
-        console.log("Raw API response:", responseText);
-
-        // Try to parse the JSON, handling potential parsing errors
-        let jsonResponse;
-        try {
-            jsonResponse = JSON.parse(responseText);
-        } catch (parseError) {
-            console.error("JSON Parsing Error:", parseError);
-            console.error("Response that could not be parsed:", responseText);
-            throw new Error("Failed to parse API response");
-        }
-
-        console.log(jsonResponse);
-
-        if(jsonResponse.success){
-            console.log(`${jsonResponse.message}, tag number: ${jsonResponse.asset_tag_number}, asset id: ${jsonResponse.asset_id}`);
-            // Save the asset tag number and id to the node
-        } else {
-            console.log("Asset not registered in central database");
-        }
-        return jsonResponse;
-
-    } catch (error) {
-        console.log("Error saving changes to asset register API", error);
-    }
-}
-
-
-async fetchData(url, fallbackUrl) {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-    const responsData =  await response.json();
-    //responsData
-    const data = responsData.data;
-    /* .map(item => {
-      const { vendor_name, ...rest } = item;
-      return {
-      name: vendor_name,
-      ...rest
-      };
-    }); */
-    console.log(url);
-    console.log("Response Data: ", data);
-    return data;
-
-  } catch (err) {
-    console.warn(
-      `Primary URL failed: ${url}. Trying fallback URL: ${fallbackUrl}`,
-      err
-    );
-    try {
-      const response = await fetch(fallbackUrl);
-      if (!response.ok)
-        throw new Error(`HTTP error! status: ${response.status}`);
-      return await response.json();
-    } catch (fallbackErr) {
-      console.error("Both primary and fallback URLs failed:", fallbackErr);
-      return [];
-    }
-  }
-}
-
-async fetchProjectData(url) {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-    const responsData =  await response.json();
-    console.log("Response Data: ", responsData);
-    return responsData;
-
-  } catch (err) {
-  }
-}
-
-async populateDropdown(
-  htmlElement,
-  options,
-  node,
-  property,
-  callback
-) {
-  this.generateHtml(htmlElement, options, node[property]);
-
-  htmlElement.addEventListener("change", async (e) => {
-    const newValue = e.target.value;
-    console.log(`Dropdown changed: ${property} = ${newValue}`);
-    node[property] = newValue;
-
-    RED.nodes.dirty(true);
-    if (callback) await callback(newValue); // Ensure async callback completion
-  });
-}
-
-// Helper function to construct a URL from a base and path internal
-constructUrl(base, ...paths) {
-
-  // Remove trailing slash from base and leading slashes from paths
-  const sanitizedBase = (base || "").replace(/\/+$/, "");
-  const sanitizedPaths = paths.map((path) => path.replace(/^\/+|\/+$/g, ""));
-
-  // Join sanitized base and paths
-  const url = `${sanitizedBase}/${sanitizedPaths.join("/")}`;
-  console.log("Base:", sanitizedBase);
-  console.log("Paths:", sanitizedPaths);
-  console.log("Constructed URL:", url);
-  return url;
-}
-
-//Adjust for API Gateway
-constructCloudURL(base, ...paths) {
-  // Remove trailing slash from base and leading slashes from paths
-  const sanitizedBase = base.replace(/\/+$/, "");
-  const sanitizedPaths = paths.map((path) => path.replace(/^\/+|\/+$/g, ""));
-  // Join sanitized base and paths
-  const url = `${sanitizedBase}/${sanitizedPaths.join("/")}`;
-  return url;
-}
-
-populateSubTypes(configUrls, elements, node, selectedSupplier) {
-
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const assetType = configData.asset?.type?.default;
-      const supplierFolder = this.constructUrl( configUrls.local.taggcodeAPI, `${assetType}s`, selectedSupplier );
-
-      const localSubTypesUrl = this.constructUrl(supplierFolder, "subtypes.json");
-      const cloudSubTypesUrl = this.constructCloudURL(configUrls.cloud.taggcodeAPI, "/product/get_subtypesFromVendor.php?vendor_name=" + selectedSupplier);
-
-      return this.fetchData(cloudSubTypesUrl, localSubTypesUrl)
-        .then((subTypeData) => {
-          const subTypes = subTypeData.map((subType) => subType.name);
-
-          return this.populateDropdown(
-            elements.subType,
-            subTypes,
-            node,
-            "subType",
-            function (selectedSubType) {
-              if (selectedSubType) {
-                // When subType changes, update both models and units
-                this.populateModels(
-                  configUrls,
-                  elements,
-                  node,
-                  selectedSupplier,
-                  selectedSubType
-                );
-                this.populateUnitsForSubType(
-                  configUrls,
-                  elements,
-                  node,
-                  selectedSubType
-                );
-              }
-            }
-          );
-        })
-        .then(() => {
-          // If we have a saved subType, trigger both models and units population
-          if (node.subType) {
-            this.populateModels(
-              configUrls,
-              elements,
-              node,
-              selectedSupplier,
-              node.subType
-            );
-            this.populateUnitsForSubType(configUrls, elements, node, node.subType);
-          }
-          //console.log("In fetch part of subtypes ");
-          // Store all data from selected model
-/*           node["modelMetadata"] = modelData.find(
-            (model) => model.name === node.model
-          );
-          console.log("Model Metadata: ", node["modelMetadata"]); */
-        });
-    })
-    .catch((error) => {
-      console.error("Error populating subtypes:", error);
-    });
-}
-
-populateUnitsForSubType(configUrls, elements, node, selectedSubType) {
-  // Fetch the units data
-  this.fetchData(configUrls.cloud.units, configUrls.local.units)
-    .then((unitsData) => {
-      // Find the category that matches the subType name
-      const categoryData = unitsData.units.find(
-        (category) =>
-          category.category.toLowerCase() === selectedSubType.toLowerCase()
-      );
-
-      if (categoryData) {
-        // Extract just the unit values and descriptions
-        const units = categoryData.values.map((unit) => ({
-          value: unit.value,
-          description: unit.description,
-        }));
-
-        // Create the options array with descriptions as labels
-        const options = units.map((unit) => ({
-          value: unit.value,
-          label: `${unit.value} - ${unit.description}`,
-        }));
-
-        // Populate the units dropdown
-        this.populateDropdown(
-          elements.unit,
-          options.map((opt) => opt.value),
-          node,
-          "unit"
-        );
-
-        // If there's no currently selected unit but we have options, select the first one
-        if (!node.unit && options.length > 0) {
-          node.unit = options[0].value;
-          elements.unit.value = options[0].value;
-        }
-      } else {
-        // If no matching category is found, provide a default % option
-        const defaultUnits = [{ value: "%", description: "Percentage" }];
-        this.populateDropdown(
-          elements.unit,
-          defaultUnits.map((unit) => unit.value),
-          node,
-          "unit"
-        );
-        console.warn(
-          `No matching unit category found for subType: ${selectedSubType}`
-        );
-      }
-    })
-    .catch((error) => {
-      console.error("Error fetching units:", error);
-    });
-}
-
-populateModels(
-  configUrls,
-  elements,
-  node,
-  selectedSupplier,
-  selectedSubType
-) {
-
-  this.fetchData(configUrls.cloud.config, configUrls.local.config)
-    .then((configData) => {
-      const assetType = configData.asset?.type?.default;
-      // save assetType to fetch later 
-      node.assetType = assetType;
-
-      const supplierFolder = this.constructUrl( configUrls.local.taggcodeAPI,`${assetType}s`,selectedSupplier);
-      const subTypeFolder = this.constructUrl(supplierFolder, selectedSubType);
-      const localModelsUrl = this.constructUrl(subTypeFolder, "models.json");
-      const cloudModelsUrl  = this.constructCloudURL(configUrls.cloud.taggcodeAPI, "/product/get_product_models.php?vendor_name=" + selectedSupplier + "&product_subtype_name=" + selectedSubType);
-
-      return this.fetchData(cloudModelsUrl, localModelsUrl).then((modelData) => {
-        const models = modelData.map((model) => model.name); // use this to populate the dropdown
-
-        // If a model is already selected, store its metadata immediately
-        if (node.model) {
-          node["modelMetadata"] = modelData.find((model) => model.name === node.model);
-        }
-
-        this.populateDropdown(elements.model, models, node, "model", (selectedModel) => {
-          // Store only the metadata for the selected model
-          node["modelMetadata"] = modelData.find((model) => model.name === selectedModel);
-        });
-
-      });
-
-    })
-    .catch((error) => {
-      console.error("Error populating models:", error);
-    });
-}
-
-generateHtml(htmlElement, options, savedValue) {
-  htmlElement.innerHTML = options.length
-    ? `<option value="">Select...</option>${options
-        .map((opt) => `<option value="${opt}">${opt}</option>`)
-        .join("")}`
-    : "<option value=''>No options available</option>";
-
-  if (savedValue && options.includes(savedValue)) {
-    htmlElement.value = savedValue;
-  }
-}
-
-createMenuUtilsEndpoint(RED, nodeName, customHelpers = {}) {
-    RED.httpAdmin.get(`/${nodeName}/resources/menuUtils.js`, function(req, res) {
-      console.log(`Serving menuUtils.js for ${nodeName} node`);
-      res.set('Content-Type', 'application/javascript');
-      
-      const browserCode = this.generateMenuUtilsCode(nodeName, customHelpers);
-      res.send(browserCode);
-    }.bind(this));
-  }
-
-generateMenuUtilsCode(nodeName, customHelpers = {}) {
-  const defaultHelpers = {
-    validateRequired: `function(value) {
-      return value && value.toString().trim() !== '';
-    }`,
-    formatDisplayValue: `function(value, unit) {
-      return \`\${value} \${unit || ''}\`.trim();
-    }`
-  };
-
-  const allHelpers = { ...defaultHelpers, ...customHelpers };
-
-  const helpersCode = Object.entries(allHelpers)
-    .map(([name, func]) => `        ${name}: ${func}`)
-    .join(',\n');
-
-  const classCode = MenuUtils.toString(); // <-- this gives full class MenuUtils {...}
-
-  return `
-    // Create EVOLV namespace structure
-    window.EVOLV = window.EVOLV || {};
-    window.EVOLV.nodes = window.EVOLV.nodes || {};
-    window.EVOLV.nodes.${nodeName} = window.EVOLV.nodes.${nodeName} || {};
-
-    // Inject MenuUtils class
-    ${classCode}
-
-    // Expose MenuUtils instance to namespace
-    window.EVOLV.nodes.${nodeName}.utils = {
-      menuUtils: new MenuUtils(),
-
-      helpers: {
-${helpersCode}
-      }
-    };
-
-    // Optionally expose globally
-    window.MenuUtils = MenuUtils;
-
-    console.log('${nodeName} utilities loaded in namespace');
-  `;
-}
-
-}
-
-module.exports = MenuUtils;

src/helper/outputUtils.js

@@ -1,18 +1,19 @@
+const { getFormatter } = require('./formatters');
+
 //this class will handle the output events for the node red node
 class OutputUtils {
   constructor() {
-    this.output ={};
-    this.output['influxdb'] = {};
-    this.output['process'] = {};
+    this.output = {};
   }
 
   checkForChanges(output, format) {
     if (!output || typeof output !== 'object') {
       return {};
     }
+    this.output[format] = this.output[format] || {};
     const changedFields = {};
     for (const key in output) {
-      if (output.hasOwnProperty(key) && output[key] !== this.output[format][key]) {
+      if (Object.prototype.hasOwnProperty.call(output, key) && output[key] !== this.output[format][key]) {
         let value = output[key];
         // For fields: if the value is an object (and not a Date), stringify it.
         if (value !== null && typeof value === 'object' && !(value instanceof Date)) {
@@ -30,66 +31,56 @@ class OutputUtils {
   }
 
   formatMsg(output, config, format) {
-  
-    //define emtpy message
       let msg = {};
 
       // Compare output with last output and only include changed values
       const changedFields = this.checkForChanges(output,format);
 
       if (Object.keys(changedFields).length > 0) {
-
-        switch (format) {
-          case 'influxdb':  
-            // Extract the relevant config properties.
-            const relevantConfig = this.extractRelevantConfig(config);
-            // Flatten the tags so that no nested objects are passed on.
-            const flatTags = this.flattenTags(relevantConfig);
-            msg = this.influxDBFormat(changedFields, config, flatTags);
-            
-            break;
-
-          case 'process':
-
-            // Compare output with last output and only include changed values
-            msg = this.processFormat(changedFields,config);
-            //console.log(msg);
-            break;
-
-          default:
-            return null;
-        }
+        const measurement = config.general.name;
+        const flatTags = this.flattenTags(this.extractRelevantConfig(config));
+        const formatterName = this.resolveFormatterName(config, format);
+        const formatter = getFormatter(formatterName);
+        const payload = formatter.format(measurement, {
+          fields: changedFields,
+          tags: flatTags,
+          config,
+          channel: format,
+        });
+        msg = this.wrapMessage(measurement, payload);
         return msg;
       }
       return null;
   }
-  
 
-  influxDBFormat(changedFields, config , flatTags) {
-    // Create the measurement and topic using softwareType and name config.functionality.softwareType + .
-    const measurement = `${config.functionality?.softwareType}_${config.general?.id}`;
-    const payload = {
-      measurement: measurement,
-      fields: changedFields,
-      tags: flatTags,
-      timestamp: new Date(),
+  resolveFormatterName(config, channel) {
+    const outputConfig = config.output || {};
+    if (channel === 'process') {
+      return outputConfig.process || 'process';
+    }
+    if (channel === 'influxdb') {
+      return outputConfig.dbase || 'influxdb';
+    }
+    return outputConfig[channel] || channel;
+  }
+
+  wrapMessage(measurement, payload) {
+    return {
+      topic: measurement,
+      payload,
     };
-
-    const topic = measurement;
-    const msg = { topic: topic, payload: payload };
-    return msg;
   }
 
   flattenTags(obj) {
     const result = {};
     for (const key in obj) {
-      if (obj.hasOwnProperty(key)) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
         const value = obj[key];
         if (value !== null && typeof value === 'object' && !(value instanceof Date)) {
           // Recursively flatten the nested object.
           const flatChild = this.flattenTags(value);
           for (const childKey in flatChild) {
-            if (flatChild.hasOwnProperty(childKey)) {
+            if (Object.prototype.hasOwnProperty.call(flatChild, childKey)) {
               result[`${key}_${childKey}`] = String(flatChild[childKey]);
             }
           }
@@ -103,7 +94,7 @@ class OutputUtils {
   }
 
   extractRelevantConfig(config) {
-    
+
     return {
       // general properties
       id: config.general?.id,
@@ -120,15 +111,6 @@ class OutputUtils {
       unit: config.general?.unit,
     };
   }
-
-  processFormat(changedFields,config) {
-        // Create the measurement and topic using softwareType and name config.functionality.softwareType + .
-        const measurement = `${config.functionality?.softwareType}_${config.general?.id}`;
-        const payload = changedFields;
-        const topic = measurement;
-        const msg = { topic: topic, payload: payload };
-        return msg;
-  }
 }
 
 module.exports = OutputUtils;

src/helper/validationUtils.js

@@ -1,38 +1,52 @@
 /**
  * @file validation.js
  *
- * Permission is hereby granted to any person obtaining a copy of this software 
- * and associated documentation files (the "Software"), to use it for personal 
+ * Permission is hereby granted to any person obtaining a copy of this software
+ * and associated documentation files (the "Software"), to use it for personal
  * or non-commercial purposes, with the following restrictions:
  *
- * 1. **No Copying or Redistribution**: The Software or any of its parts may not 
- *    be copied, merged, distributed, sublicensed, or sold without explicit 
+ * 1. **No Copying or Redistribution**: The Software or any of its parts may not
+ *    be copied, merged, distributed, sublicensed, or sold without explicit
  *    prior written permission from the author.
- * 
- * 2. **Commercial Use**: Any use of the Software for commercial purposes requires 
+ *
+ * 2. **Commercial Use**: Any use of the Software for commercial purposes requires
  *    a valid license, obtainable only with the explicit consent of the author.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
- * FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER 
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, 
- * OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+ * OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Ownership of this code remains solely with the original author. Unauthorized 
+ * Ownership of this code remains solely with the original author. Unauthorized
  * use of this Software is strictly prohibited.
- 
+
     * @summary Validation utility for validating and constraining configuration values.
     * @description Validation utility for validating and constraining configuration values.
     * @module ValidationUtils
     * @requires Logger
     * @exports ValidationUtils
-    * @version 0.1.0
+    * @version 0.2.0
     * @since 0.1.0
 */
 
 const Logger = require("./logger");
+const { validateNumber, validateInteger, validateBoolean, validateString, validateEnum } = require("./validators/typeValidators");
+const { validateArray, validateSet, validateObject } = require("./validators/collectionValidators");
+const { validateCurve, validateMachineCurve } = require("./validators/curveValidator");
+
+// Strategy registry: maps rules.type to a handler function
+const VALIDATORS = {
+    number:       (cv, rules, fs, name, key, logger)       => validateNumber(cv, rules, fs, name, key, logger),
+    integer:      (cv, rules, fs, name, key, logger)       => validateInteger(cv, rules, fs, name, key, logger),
+    boolean:      (cv, _rules, _fs, name, key, logger)     => validateBoolean(cv, name, key, logger),
+    string:       (cv, rules, fs, name, key, logger)       => validateString(cv, rules, fs, name, key, logger),
+    enum:         (cv, rules, fs, name, key, logger)       => validateEnum(cv, rules, fs, name, key, logger),
+    array:        (cv, rules, fs, name, key, logger)       => validateArray(cv, rules, fs, name, key, logger),
+    set:          (cv, rules, fs, name, key, logger)       => validateSet(cv, rules, fs, name, key, logger),
+};
 
 class ValidationUtils {
   constructor(IloggerEnabled, IloggerLevel) {
@@ -77,7 +91,7 @@ class ValidationUtils {
             delete config[key];
             }
         }
-    
+
         // Validate each key in the schema and loop over wildcards if they are not in schema
         for ( const key in schema ) {
 
@@ -87,7 +101,7 @@ class ValidationUtils {
 
             const fieldSchema = schema[key];
             const { rules = {} } = fieldSchema;
-    
+
             // Default to the schema's default value if the key is missing
             if (config[key] === undefined) {
                 if (fieldSchema.default === undefined) {
@@ -118,77 +132,58 @@ class ValidationUtils {
                 configValue = config[key] !== undefined ? config[key] : fieldSchema.default;
             }
 
-            // Attempt to parse the value to the expected type if possible
-            switch (rules.type) {
-
-                case "number":
-                    configValue = this.validateNumber(configValue, rules, fieldSchema, name, key);
-                    break;
-                case "boolean":
-                    configValue = this.validateBoolean(configValue, name, key);
-                    break;
-    
-                case "string":
-                    configValue = this.validateString(configValue,rules,fieldSchema, name, key);
-                    break;
-    
-                case "array":
-                    configValue = this.validateArray(configValue, rules, fieldSchema, name, key);
-                    break;
-                
-                case "set":
-                    configValue = this.validateSet(configValue, rules, fieldSchema, name, key);
-                    break;
-    
-                case "object":
-                    configValue = this.validateObject(configValue, rules, fieldSchema, name, key);
-                    break;
-
-                case "enum":
-                    configValue = this.validateEnum(configValue, rules, fieldSchema, name, key);
-                    break;
-
-                case "curve":
-                    validatedConfig[key] = this.validateCurve(configValue,fieldSchema.default);
-                    continue;
-
-                case "machineCurve":
-                    validatedConfig[key] = this.validateMachineCurve(configValue,fieldSchema.default);
-                    continue;
-
-                case "integer":
-                    validatedConfig[key] = this.validateInteger(configValue, rules, fieldSchema, name, key);
-                    continue;
-
-                case undefined:
-                    // If we see 'rules.schema' but no 'rules.type', treat it like an object:
-                    if (rules.schema && !rules.type) {
-                        // Log a warning and skip the extra pass for nested schema
-                        this.logger.warn(
-                            `${name}.${key} has a nested schema but no type. ` +
-                            `Treating it as type="object" to skip extra pass.`
-                        );
-                    } else {
-                        // Otherwise, fallback to your existing "validateUndefined" logic
-                        validatedConfig[key] = this.validateUndefined(configValue, fieldSchema, name, key);
-                    }
-                    continue;
-
-                default:
-                    this.logger.warn(`${name}.${key} has an unknown validation type: ${rules.type}. Skipping validation.`);
-                    validatedConfig[key] = fieldSchema.default;
-                    continue;
+            // Handle curve types (they use continue, so handle separately)
+            if (rules.type === "curve") {
+                validatedConfig[key] = validateCurve(configValue, fieldSchema.default, this.logger);
+                continue;
             }
-    
+            if (rules.type === "machineCurve") {
+                validatedConfig[key] = validateMachineCurve(configValue, fieldSchema.default, this.logger);
+                continue;
+            }
+
+            // Handle object type (needs recursive validateSchema reference)
+            if (rules.type === "object") {
+                validatedConfig[key] = validateObject(
+                    configValue, rules, fieldSchema, name, key,
+                    (c, s, n) => this.validateSchema(c, s, n),
+                    this.logger
+                );
+                continue;
+            }
+
+            // Handle undefined type
+            if (rules.type === undefined) {
+                if (rules.schema && !rules.type) {
+                    this.logger.warn(
+                        `${name}.${key} has a nested schema but no type. ` +
+                        `Treating it as type="object" to skip extra pass.`
+                    );
+                } else {
+                    validatedConfig[key] = this.validateUndefined(configValue, fieldSchema, name, key);
+                }
+                continue;
+            }
+
+            // Use the strategy registry for all other types
+            const handler = VALIDATORS[rules.type];
+            if (handler) {
+                configValue = handler(configValue, rules, fieldSchema, name, key, this.logger);
+            } else {
+                this.logger.warn(`${name}.${key} has an unknown validation type: ${rules.type}. Skipping validation.`);
+                validatedConfig[key] = fieldSchema.default;
+                continue;
+            }
+
             // Assign the validated or converted value
             validatedConfig[key] = configValue;
         }
-    
+
         // Ignore unknown keys by not processing them at all
         this.logger.info(`Validation completed for ${name}.`);
 
         return validatedConfig;
-    } 
+    }
 
     removeUnwantedKeys(obj) {
 
@@ -216,358 +211,6 @@ class ValidationUtils {
         }
         return obj;
     }
-      
-    validateMachineCurve(curve, defaultCurve) {
-        if (!curve || typeof curve !== "object" || Object.keys(curve).length === 0) {
-            this.logger.warn("Curve is missing or invalid. Defaulting to basic curve.");
-            return defaultCurve;
-        }
-
-        // Validate that nq and np exist and are objects
-        const { nq, np } = curve;
-        if (!nq || typeof nq !== "object" || !np || typeof np !== "object") {
-            this.logger.warn("Curve must contain valid 'nq' and 'np' objects. Defaulting to basic curve.");
-            return defaultCurve;
-        }
-
-        // Validate that each dimension key points to a valid object with x and y arrays
-        const validatedNq = this.validateDimensionStructure(nq, "nq");
-        const validatedNp = this.validateDimensionStructure(np, "np");
-
-        if (!validatedNq || !validatedNp) {
-            return defaultCurve;
-        }
-
-        return { nq: validatedNq, np: validatedNp }; // Return the validated curve
-    }
-
-    validateCurve(curve, defaultCurve) {
-        if (!curve || typeof curve !== "object" || Object.keys(curve).length === 0) {
-            this.logger.warn("Curve is missing or invalid. Defaulting to basic curve.");
-            return defaultCurve;
-        }
-
-        // Validate that each dimension key points to a valid object with x and y arrays
-        const validatedCurve = this.validateDimensionStructure(curve, "curve");
-        if (!validatedCurve) {
-            return defaultCurve;
-        }
-
-        return validatedCurve; // Return the validated curve
-    }
-
-    validateDimensionStructure(dimension, name) {
-        const validatedDimension = {};
-
-        for (const [key, value] of Object.entries(dimension)) {
-            // Validate that each key points to an object with x and y arrays
-            if (typeof value !== "object") {
-                this.logger.warn(`Dimension '${name}' key '${key}' is not valid. Returning to default.`);
-                return false;
-            }
-            // Validate that x and y are arrays
-            else if (!Array.isArray(value.x) || !Array.isArray(value.y)) {
-                this.logger.warn(`Dimension '${name}' key '${key}' is missing x or y arrays. Converting to arrays.`);
-                // Try to convert to arrays first
-                value.x = Object.values(value.x);
-                value.y = Object.values(value.y);
-
-                // If still not arrays return false
-                if (!Array.isArray(value.x) || !Array.isArray(value.y)) {
-                    this.logger.warn(`Dimension '${name}' key '${key}' is not valid. Returning to default.`);
-                    return false;
-                }
-            }
-            // Validate that x and y arrays are the same length
-            else if (value.x.length !== value.y.length) {
-                this.logger.warn(`Dimension '${name}' key '${key}' has mismatched x and y lengths. Ignoring this key.`);
-                return false;
-            }
-            // Validate that x values are in ascending order
-            else if (!this.isSorted(value.x)) {
-                this.logger.warn(`Dimension '${name}' key '${key}' has unsorted x values. Sorting...`);
-                return false;
-            }
-            // Validate that x values are unique
-            else if (!this.isUnique(value.x)) {
-                this.logger.warn(`Dimension '${name}' key '${key}' has duplicate x values. Removing duplicates...`);
-                return false;
-            }
-            // Validate that y values are numbers
-            else if (!this.areNumbers(value.y)) {
-                this.logger.warn(`Dimension '${name}' key '${key}' has non-numeric y values. Ignoring this key.`);
-                return false;
-            }
-
-            validatedDimension[key] = value;
-        }
-        return validatedDimension;
-    }
-
-    isSorted(arr) {
-        return arr.every((_, i) => i === 0 || arr[i] >= arr[i - 1]);
-    }
-
-    isUnique(arr) {
-        return new Set(arr).size === arr.length;
-    }
-
-    areNumbers(arr) {
-        return arr.every((x) => typeof x === "number");
-    }
-
-    validateNumber(configValue, rules, fieldSchema, name, key) {
-
-        if (typeof configValue !== "number") {
-            const parsedValue = parseFloat(configValue);
-            if (!isNaN(parsedValue)) {
-                this.logger.warn(`${name}.${key} was parsed to a number: ${configValue} -> ${parsedValue}`);
-                configValue = parsedValue;
-            }
-        }
-
-        if (rules.min !== undefined && configValue < rules.min) {
-            this.logger.warn(
-                `${name}.${key} is below the minimum (${rules.min}). Using default value.`
-            );
-            return fieldSchema.default;
-        }
-        if (rules.max !== undefined && configValue > rules.max) {
-            this.logger.warn(
-                `${name}.${key} exceeds the maximum (${rules.max}). Using default value.`
-            );
-            return fieldSchema.default;
-        }
-        
-        this.logger.debug(`${name}.${key} is a valid number: ${configValue}`);
-
-        return configValue;
-    }
-
-
-    validateInteger(configValue, rules, fieldSchema, name, key) {
-        if (typeof configValue !== "number" || !Number.isInteger(configValue)) {
-            const parsedValue = parseInt(configValue, 10);
-            if (!isNaN(parsedValue) && Number.isInteger(parsedValue)) {
-                this.logger.warn(`${name}.${key} was parsed to an integer: ${configValue} -> ${parsedValue}`);
-                configValue = parsedValue;
-            } else {
-                this.logger.warn(`${name}.${key} is not a valid integer. Using default value.`);
-                return fieldSchema.default;
-            }
-        }
-
-        if (rules.min !== undefined && configValue < rules.min) {
-            this.logger.warn(`${name}.${key} is below the minimum integer value (${rules.min}). Using default value.`);
-            return fieldSchema.default;
-        }
-
-        if (rules.max !== undefined && configValue > rules.max) {
-            this.logger.warn(`${name}.${key} exceeds the maximum integer value (${rules.max}). Using default value.`);
-            return fieldSchema.default;
-        }
-
-        this.logger.debug(`${name}.${key} is a valid integer: ${configValue}`);
-        return configValue;
-    }
-
-    validateBoolean(configValue, name, key) {
-        if (typeof configValue !== "boolean") {
-            if (configValue === "true" || configValue === "false") {
-                const parsedValue = configValue === "true";
-                this.logger.debug(`${name}.${key} was parsed to a boolean: ${configValue} -> ${parsedValue}`);
-                configValue = parsedValue;
-            }
-        }
-        return configValue;
-    }
-
-    validateString(configValue, rules, fieldSchema, name, key) {
-        let newConfigValue = configValue;
-
-        if (typeof configValue !== "string") {
-            //check if the value is nullable
-            if(rules.nullable){
-                if(configValue === null){
-                    return null;
-                }
-            }
-
-            this.logger.warn(`${name}.${key} is not a string. Trying to convert to string.`);
-            newConfigValue = String(configValue); // Coerce to string if not already
-        }
-        
-        //check if the string is a valid string after conversion
-        if (typeof newConfigValue !== "string") {
-            this.logger.warn(`${name}.${key} is not a valid string. Using default value.`);
-            return fieldSchema.default;
-        }
-
-        const keyString = `${name}.${key}`;
-        const normalizeMode = rules.normalize || this._resolveStringNormalizeMode(keyString);
-        const preserveCase = normalizeMode !== "lowercase";
-
-        // Check for uppercase characters and convert to lowercase if present
-        if (!preserveCase && newConfigValue !== newConfigValue.toLowerCase()) {
-            this._logOnce(
-                "info",
-                `normalize-lowercase:${keyString}`,
-                `${name}.${key} normalized to lowercase: ${newConfigValue} -> ${newConfigValue.toLowerCase()}`
-            );
-            newConfigValue = newConfigValue.toLowerCase();
-        }
-
-        return newConfigValue;
-    }
-
-    _isUnitLikeField(path) {
-        const normalized = String(path || "").toLowerCase();
-        if (!normalized) return false;
-        return /(^|\.)([a-z0-9]*unit|units)(\.|$)/.test(normalized)
-            || normalized.includes(".curveunits.");
-    }
-
-    _resolveStringNormalizeMode(path) {
-        const normalized = String(path || "").toLowerCase();
-        if (!normalized) return "none";
-
-        if (this._isUnitLikeField(normalized)) return "none";
-        if (normalized.endsWith(".name")) return "none";
-        if (normalized.endsWith(".model")) return "none";
-        if (normalized.endsWith(".supplier")) return "none";
-        if (normalized.endsWith(".role")) return "none";
-        if (normalized.endsWith(".description")) return "none";
-
-        if (normalized.endsWith(".softwaretype")) return "lowercase";
-        if (normalized.endsWith(".type")) return "lowercase";
-        if (normalized.endsWith(".category")) return "lowercase";
-
-        return "lowercase";
-    }
-
-    validateSet(configValue, rules, fieldSchema, name, key) {
-        // 1. Ensure we have a Set. If not, use default.
-        if (!(configValue instanceof Set)) {
-            this.logger.debug(`${name}.${key} is not a Set. Converting to one using default value.`);
-            return new Set(fieldSchema.default);
-        }
-    
-        // 2. Convert the Set to an array for easier filtering.
-        const validatedArray = [...configValue]
-            .filter((item) => {
-                // 3. Filter based on `rules.itemType`.
-                switch (rules.itemType) {
-                    case "number":
-                        return typeof item === "number";
-                    case "string":
-                        return typeof item === "string";
-                    case "null":
-                        // "null" might mean no type restriction (your usage may vary).
-                        return true;
-                    default:
-                        // Fallback if itemType is something else
-                        return typeof item === rules.itemType;
-                }
-            })
-            .slice(0, rules.maxLength || Infinity);
-    
-        // 4. Check if the filtered array meets the minimum length.
-        const minLength = Number.isInteger(rules.minLength) ? rules.minLength : 0;
-        if (validatedArray.length < minLength) {
-            this.logger.warn(
-                `${name}.${key} contains fewer items than allowed (${minLength}). Using default value.`
-            );
-            return new Set(fieldSchema.default);
-        }
-    
-        // 5. Return a new Set containing only the valid items.
-        return new Set(validatedArray);
-    }
-
-    validateArray(configValue, rules, fieldSchema, name, key) {
-        if (!Array.isArray(configValue)) {
-            this.logger.debug(`${name}.${key} is not an array. Using default value.`);
-            return fieldSchema.default;
-        }
-
-        // Validate individual items in the array
-        const validatedArray = configValue
-            .filter((item) => {
-                switch (rules.itemType) {
-                    case "number":
-                        return typeof item === "number";
-                    case "string":
-                        return typeof item === "string";
-                    case "null":
-                        // anything goes
-                        return true;
-                    default:
-                        return typeof item === rules.itemType;
-                }
-            })
-            .slice(0, rules.maxLength || Infinity);
-
-        const minLength = Number.isInteger(rules.minLength) ? rules.minLength : 0;
-        if (validatedArray.length < minLength) {
-            this.logger.warn(
-                `${name}.${key} contains fewer items than allowed (${minLength}). Using default value.`
-            );
-            return fieldSchema.default;
-        }
-
-        return validatedArray;
-    }
-
-    validateObject(configValue, rules, fieldSchema, name, key) {
-        if (typeof configValue !== "object" || Array.isArray(configValue)) {
-            this.logger.warn(`${name}.${key} is not a valid object. Using default value.`);
-            return fieldSchema.default;
-        }
-
-        if (rules.schema) {
-            // Recursively validate nested objects if a schema is defined
-            return this.validateSchema(configValue || {}, rules.schema, `${name}.${key}`);
-        } else {
-            // If no schema is defined, log a warning and use the default
-            this.logger.warn(`${name}.${key} is an object with no schema. Using default value.`);
-            return fieldSchema.default;
-        }
-    }
-
-    validateEnum(configValue, rules, fieldSchema, name, key) {
-
-        if (Array.isArray(rules.values)) {
-
-            //if value is null take default
-            if(configValue === null){
-                this.logger.warn(`${name}.${key} is null. Using default value.`);
-                return fieldSchema.default;
-            }
-
-            if (typeof configValue !== "string") {
-                this.logger.warn(`${name}.${key} is not a valid enum string. Using default value.`);
-                return fieldSchema.default;
-            }
-
-            const validValues = rules.values.map(e => e.value.toLowerCase());
-
-            //remove caps
-            configValue = configValue.toLowerCase();
-
-            if (!validValues.includes(configValue)) {
-                this.logger.warn(
-                    `${name}.${key} has an invalid value : ${configValue}. Allowed values: [${validValues.join(", ")}]. Using default value.`
-                );
-                return fieldSchema.default;
-            }
-        } else {
-            this.logger.warn(
-                `${name}.${key} is an enum with no 'values' array. Using default value.`
-            );
-            return fieldSchema.default;
-        }
-        return configValue;
-    }
 
     validateUndefined(configValue, fieldSchema, name, key) {
         if (typeof configValue === "object" && !Array.isArray(configValue)) {
@@ -576,7 +219,7 @@ class ValidationUtils {
 
             // Recursively validate the nested object
             return this.validateSchema( configValue || {}, fieldSchema, `${name}.${key}`);
-            } 
+            }
             else {
                 this.logger.warn(`${name}.${key} has no defined rules. Using default value.`);
                 return fieldSchema.default;

src/helper/validators/collectionValidators.js

@@ -0,0 +1,66 @@
+/**
+ * Standalone collection validation functions extracted from validationUtils.js.
+ */
+
+function validateArray(configValue, rules, fieldSchema, name, key, logger) {
+    if (!Array.isArray(configValue)) {
+        logger.info(`${name}.${key} is not an array. Using default value.`);
+        return fieldSchema.default;
+    }
+    const validatedArray = configValue
+        .filter((item) => {
+            switch (rules.itemType) {
+                case "number": return typeof item === "number";
+                case "string": return typeof item === "string";
+                case "null": return true;
+                default: return typeof item === rules.itemType;
+            }
+        })
+        .slice(0, rules.maxLength || Infinity);
+    if (validatedArray.length < (rules.minLength || 1)) {
+        logger.warn(
+            `${name}.${key} contains fewer items than allowed (${rules.minLength}). Using default value.`
+        );
+        return fieldSchema.default;
+    }
+    return validatedArray;
+}
+
+function validateSet(configValue, rules, fieldSchema, name, key, logger) {
+    if (!(configValue instanceof Set)) {
+        logger.info(`${name}.${key} is not a Set. Converting to one using default value.`);
+        return new Set(fieldSchema.default);
+    }
+    const validatedArray = [...configValue]
+        .filter((item) => {
+            switch (rules.itemType) {
+                case "number": return typeof item === "number";
+                case "string": return typeof item === "string";
+                case "null": return true;
+                default: return typeof item === rules.itemType;
+            }
+        })
+        .slice(0, rules.maxLength || Infinity);
+    if (validatedArray.length < (rules.minLength || 1)) {
+        logger.warn(
+            `${name}.${key} contains fewer items than allowed (${rules.minLength}). Using default value.`
+        );
+        return new Set(fieldSchema.default);
+    }
+    return new Set(validatedArray);
+}
+
+function validateObject(configValue, rules, fieldSchema, name, key, validateSchemaFn, logger) {
+    if (typeof configValue !== "object" || Array.isArray(configValue)) {
+        logger.warn(`${name}.${key} is not a valid object. Using default value.`);
+        return fieldSchema.default;
+    }
+    if (rules.schema) {
+        return validateSchemaFn(configValue || {}, rules.schema, `${name}.${key}`);
+    } else {
+        logger.warn(`${name}.${key} is an object with no schema. Using default value.`);
+        return fieldSchema.default;
+    }
+}
+
+module.exports = { validateArray, validateSet, validateObject };

src/helper/validators/curveValidator.js

@@ -0,0 +1,108 @@
+/**
+ * Curve validation strategies for machine curves and generic curves.
+ * Extracted from validationUtils.js for modularity.
+ */
+
+function isSorted(arr) {
+    return arr.every((_, i) => i === 0 || arr[i] >= arr[i - 1]);
+}
+
+function isUnique(arr) {
+    return new Set(arr).size === arr.length;
+}
+
+function areNumbers(arr) {
+    return arr.every((x) => typeof x === "number");
+}
+
+function validateDimensionStructure(dimension, name, logger) {
+    const validatedDimension = {};
+
+    for (const [key, value] of Object.entries(dimension)) {
+        if (typeof value !== "object") {
+            logger.warn(`Dimension '${name}' key '${key}' is not valid. Returning to default.`);
+            return false;
+        }
+        else if (!Array.isArray(value.x) || !Array.isArray(value.y)) {
+            logger.warn(`Dimension '${name}' key '${key}' is missing x or y arrays. Converting to arrays.`);
+            value.x = Object.values(value.x);
+            value.y = Object.values(value.y);
+            if (!Array.isArray(value.x) || !Array.isArray(value.y)) {
+                logger.warn(`Dimension '${name}' key '${key}' is not valid. Returning to default.`);
+                return false;
+            }
+        }
+        else if (value.x.length !== value.y.length) {
+            logger.warn(`Dimension '${name}' key '${key}' has mismatched x and y lengths. Ignoring this key.`);
+            return false;
+        }
+        else if (!isSorted(value.x)) {
+            logger.warn(`Dimension '${name}' key '${key}' has unsorted x values. Sorting...`);
+            const indices = value.x.map((_v, i) => i);
+            indices.sort((a, b) => value.x[a] - value.x[b]);
+            value.x = indices.map(i => value.x[i]);
+            value.y = indices.map(i => value.y[i]);
+        }
+        if (!isUnique(value.x)) {
+            logger.warn(`Dimension '${name}' key '${key}' has duplicate x values. Removing duplicates...`);
+            const seen = new Set();
+            const uniqueX = [];
+            const uniqueY = [];
+            for (let i = 0; i < value.x.length; i++) {
+                if (!seen.has(value.x[i])) {
+                    seen.add(value.x[i]);
+                    uniqueX.push(value.x[i]);
+                    uniqueY.push(value.y[i]);
+                }
+            }
+            value.x = uniqueX;
+            value.y = uniqueY;
+        }
+        if (!areNumbers(value.y)) {
+            logger.warn(`Dimension '${name}' key '${key}' has non-numeric y values. Ignoring this key.`);
+            return false;
+        }
+
+        validatedDimension[key] = value;
+    }
+    return validatedDimension;
+}
+
+function validateCurve(configValue, defaultCurve, logger) {
+    if (!configValue || typeof configValue !== "object" || Object.keys(configValue).length === 0) {
+        logger.warn("Curve is missing or invalid. Defaulting to basic curve.");
+        return defaultCurve;
+    }
+    const validatedCurve = validateDimensionStructure(configValue, "curve", logger);
+    if (!validatedCurve) {
+        return defaultCurve;
+    }
+    return validatedCurve;
+}
+
+function validateMachineCurve(configValue, defaultCurve, logger) {
+    if (!configValue || typeof configValue !== "object" || Object.keys(configValue).length === 0) {
+        logger.warn("Curve is missing or invalid. Defaulting to basic curve.");
+        return defaultCurve;
+    }
+    const { nq, np } = configValue;
+    if (!nq || typeof nq !== "object" || !np || typeof np !== "object") {
+        logger.warn("Curve must contain valid 'nq' and 'np' objects. Defaulting to basic curve.");
+        return defaultCurve;
+    }
+    const validatedNq = validateDimensionStructure(nq, "nq", logger);
+    const validatedNp = validateDimensionStructure(np, "np", logger);
+    if (!validatedNq || !validatedNp) {
+        return defaultCurve;
+    }
+    return { nq: validatedNq, np: validatedNp };
+}
+
+module.exports = {
+    validateCurve,
+    validateMachineCurve,
+    validateDimensionStructure,
+    isSorted,
+    isUnique,
+    areNumbers
+};

src/helper/validators/typeValidators.js

@@ -0,0 +1,158 @@
+/**
+ * Standalone type validation functions extracted from validationUtils.js.
+ */
+
+function validateNumber(configValue, rules, fieldSchema, name, key, logger) {
+    if (typeof configValue !== "number") {
+        const parsedValue = parseFloat(configValue);
+        if (!isNaN(parsedValue)) {
+            logger.warn(`${name}.${key} was parsed to a number: ${configValue} -> ${parsedValue}`);
+            configValue = parsedValue;
+        }
+    }
+    if (rules.min !== undefined && configValue < rules.min) {
+        logger.warn(`${name}.${key} is below the minimum (${rules.min}). Using default value.`);
+        return fieldSchema.default;
+    }
+    if (rules.max !== undefined && configValue > rules.max) {
+        logger.warn(`${name}.${key} exceeds the maximum (${rules.max}). Using default value.`);
+        return fieldSchema.default;
+    }
+    logger.debug(`${name}.${key} is a valid number: ${configValue}`);
+    return configValue;
+}
+
+function validateInteger(configValue, rules, fieldSchema, name, key, logger) {
+    if (typeof configValue !== "number" || !Number.isInteger(configValue)) {
+        const parsedValue = parseInt(configValue, 10);
+        if (!isNaN(parsedValue) && Number.isInteger(parsedValue)) {
+            logger.warn(`${name}.${key} was parsed to an integer: ${configValue} -> ${parsedValue}`);
+            configValue = parsedValue;
+        } else {
+            logger.warn(`${name}.${key} is not a valid integer. Using default value.`);
+            return fieldSchema.default;
+        }
+    }
+    if (rules.min !== undefined && configValue < rules.min) {
+        logger.warn(`${name}.${key} is below the minimum integer value (${rules.min}). Using default value.`);
+        return fieldSchema.default;
+    }
+    if (rules.max !== undefined && configValue > rules.max) {
+        logger.warn(`${name}.${key} exceeds the maximum integer value (${rules.max}). Using default value.`);
+        return fieldSchema.default;
+    }
+    logger.debug(`${name}.${key} is a valid integer: ${configValue}`);
+    return configValue;
+}
+
+function validateBoolean(configValue, name, key, logger) {
+    if (typeof configValue !== "boolean") {
+        if (configValue === "true" || configValue === "false") {
+            const parsedValue = configValue === "true";
+            logger.debug(`${name}.${key} was parsed to a boolean: ${configValue} -> ${parsedValue}`);
+            configValue = parsedValue;
+        }
+    }
+    return configValue;
+}
+
+function _isUnitLikeField(path) {
+    const normalized = String(path || "").toLowerCase();
+    if (!normalized) return false;
+    return /(^|\.)([a-z0-9]*unit|units)(\.|$)/.test(normalized)
+        || normalized.includes(".curveunits.");
+}
+
+function _resolveStringNormalizeMode(path) {
+    const normalized = String(path || "").toLowerCase();
+    if (!normalized) return "none";
+
+    if (_isUnitLikeField(normalized)) return "none";
+    if (normalized.endsWith(".name")) return "none";
+    if (normalized.endsWith(".model")) return "none";
+    if (normalized.endsWith(".supplier")) return "none";
+    if (normalized.endsWith(".role")) return "none";
+    if (normalized.endsWith(".description")) return "none";
+
+    if (normalized.endsWith(".softwaretype")) return "lowercase";
+    if (normalized.endsWith(".type")) return "lowercase";
+    if (normalized.endsWith(".category")) return "lowercase";
+
+    return "lowercase";
+}
+
+function validateString(configValue, rules, fieldSchema, name, key, logger) {
+    let newConfigValue = configValue;
+
+    if (typeof configValue !== "string") {
+        //check if the value is nullable
+        if(rules.nullable){
+            if(configValue === null){
+                return null;
+            }
+        }
+
+        logger.warn(`${name}.${key} is not a string. Trying to convert to string.`);
+        newConfigValue = String(configValue); // Coerce to string if not already
+    }
+
+    //check if the string is a valid string after conversion
+    if (typeof newConfigValue !== "string") {
+        logger.warn(`${name}.${key} is not a valid string. Using default value.`);
+        return fieldSchema.default;
+    }
+
+    const keyString = `${name}.${key}`;
+    const normalizeMode = rules.normalize || _resolveStringNormalizeMode(keyString);
+    const preserveCase = normalizeMode !== "lowercase";
+
+    // Check for uppercase characters and convert to lowercase if present
+    if (!preserveCase && newConfigValue !== newConfigValue.toLowerCase()) {
+        logger.info(
+            `${name}.${key} normalized to lowercase: ${newConfigValue} -> ${newConfigValue.toLowerCase()}`
+        );
+        newConfigValue = newConfigValue.toLowerCase();
+    }
+
+    return newConfigValue;
+}
+
+function validateEnum(configValue, rules, fieldSchema, name, key, logger) {
+    if (Array.isArray(rules.values)) {
+        //if value is null take default
+        if(configValue === null){
+            logger.warn(`${name}.${key} is null. Using default value.`);
+            return fieldSchema.default;
+        }
+
+        if (typeof configValue !== "string") {
+            logger.warn(`${name}.${key} is not a valid enum string. Using default value.`);
+            return fieldSchema.default;
+        }
+
+        const validValues = rules.values.map(e => e.value.toLowerCase());
+
+        //remove caps
+        configValue = configValue.toLowerCase();
+        if (!validValues.includes(configValue)) {
+            logger.warn(
+                `${name}.${key} has an invalid value : ${configValue}. Allowed values: [${validValues.join(", ")}]. Using default value.`
+            );
+            return fieldSchema.default;
+        }
+    } else {
+        logger.warn(
+            `${name}.${key} is an enum with no 'values' array. Using default value.`
+        );
+        return fieldSchema.default;
+    }
+    return configValue;
+}
+
+module.exports = {
+    validateNumber,
+    validateInteger,
+    validateBoolean,
+    validateString,
+    validateEnum,
+};

src/measurements/Measurement.js

@@ -115,8 +115,7 @@ class Measurement {
   
   // Create a new measurement that is the difference between two positions
   static createDifference(upstreamMeasurement, downstreamMeasurement) {
-
-    if (upstreamMeasurement.type !== downstreamMeasurement.type || 
+    if (upstreamMeasurement.type !== downstreamMeasurement.type ||
         upstreamMeasurement.variant !== downstreamMeasurement.variant) {
       throw new Error('Cannot calculate difference between different measurement types or variants');
     }

src/measurements/MeasurementContainer.js

@@ -1,6 +1,7 @@
 const MeasurementBuilder = require('./MeasurementBuilder');
 const EventEmitter = require('events');
 const convertModule = require('../convert/index');
+const { POSITIONS } = require('../constants/positions');
 
 class MeasurementContainer {
   constructor(options = {},logger) {
@@ -478,7 +479,7 @@ class MeasurementContainer {
   getLaggedSample(lag = 1,requestedUnit = null ){
     const measurement = this.get();
     if (!measurement) return null;
-    
+
     let sample = measurement.getLaggedSample(lag);
     if (sample === null) return null;
 
@@ -554,7 +555,7 @@ class MeasurementContainer {
   }
 
   // Difference calculations between positions
-  difference({ from = "downstream", to = "upstream", unit: requestedUnit } = {}) {
+  difference({ from = POSITIONS.DOWNSTREAM, to = POSITIONS.UPSTREAM, unit: requestedUnit } = {}) {
     if (!this._currentType || !this._currentVariant) {
       if (this.logger) {
         this.logger.warn('difference() ignored: type and variant must be specified');
@@ -682,6 +683,8 @@ class MeasurementContainer {
     this._currentType = null;
     this._currentVariant = null;
     this._currentPosition = null;
+    this._currentDistance = null;
+    this._unit = null;
   }
 
   // Helper method for value conversion
@@ -739,11 +742,11 @@ class MeasurementContainer {
 
   _convertPositionStr2Num(positionString) {
     switch(positionString) {
-      case "atEquipment":
+      case POSITIONS.AT_EQUIPMENT:
         return 0;
-      case "upstream":
+      case POSITIONS.UPSTREAM:
         return Number.POSITIVE_INFINITY;
-      case "downstream":
+      case POSITIONS.DOWNSTREAM:
         return Number.NEGATIVE_INFINITY;
       
       default:
@@ -756,13 +759,13 @@ class MeasurementContainer {
 
   _convertPositionNum2Str(positionValue) {
     if (positionValue === 0) {
-      return "atEquipment";
+      return POSITIONS.AT_EQUIPMENT;
     }
     if (positionValue < 0) {
-      return "upstream";
+      return POSITIONS.UPSTREAM;
     }
     if (positionValue > 0) {
-      return "downstream";
+      return POSITIONS.DOWNSTREAM;
     }
     if (this.logger) {
       this.logger.warn(`Invalid position provided: ${positionValue}`);

src/measurements/examples.js

@@ -1,4 +1,7 @@
 const { MeasurementContainer } = require('./index');
+const { POSITIONS } = require('../constants/positions');
+
+const measurements = new MeasurementContainer();
 
 console.log('=== MEASUREMENT CONTAINER EXAMPLES ===\n');
 console.log('This guide shows how to use the MeasurementContainer for storing,');
@@ -27,7 +30,7 @@ console.log('\nSetting pressure values with distances:');
 basicContainer
   .type('pressure')
   .variant('measured')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .distance(1.5)
   .value(100)
   .unit('psi');
@@ -35,7 +38,7 @@ basicContainer
 basicContainer
   .type('pressure')
   .variant('measured')
-  .position('downstream')
+  .position(POSITIONS.DOWNSTREAM)
   .distance(5.2)
   .value(95)
   .unit('psi');
@@ -44,7 +47,7 @@ basicContainer
 basicContainer
   .type('pressure')
   .variant('measured')
-  .position('downstream')
+  .position(POSITIONS.DOWNSTREAM)
   .value(90); // distance 5.2 is automatically reused
 
 console.log('✅ Basic setup complete\n');
@@ -53,7 +56,7 @@ console.log('✅ Basic setup complete\n');
 const upstreamPressure = basicContainer
   .type('pressure')
   .variant('measured')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .get();
 
 console.log(`Retrieved upstream pressure: ${upstreamPressure.getCurrentValue()} ${upstreamPressure.unit}`);
@@ -83,7 +86,7 @@ console.log('Adding pressure with auto-conversion:');
 autoContainer
   .type('pressure')
   .variant('measured')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .distance(0.5)
   .value(1.5, Date.now(), 'bar'); // Input: 1.5 bar → Auto-stored as ~21.76 psi
 
@@ -91,7 +94,7 @@ autoContainer
 const converted = autoContainer
   .type('pressure')
   .variant('measured')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .get();
 
 console.log(`Stored as: ${converted.getCurrentValue()} ${converted.unit} (distance=${converted.distance}m)`);
@@ -105,14 +108,14 @@ console.log('--- Example 3: Unit Conversion on Retrieval ---');
 autoContainer
   .type('flow')
   .variant('predicted')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .distance(2.4)
   .value(100, Date.now(), 'l/min');
 
 const flowMeasurement = autoContainer
   .type('flow')
   .variant('predicted')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .get();
 
 console.log(`Flow in l/min: ${flowMeasurement.getCurrentValue('l/min')}`);
@@ -153,13 +156,13 @@ console.log('--- Example 5: Basic Value Retrieval ---');
 const upstreamVal = basicContainer
   .type('pressure')
   .variant('measured')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .getCurrentValue();
 
 const upstreamData = basicContainer
   .type('pressure')
   .variant('measured')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .get();
 
 console.log(`Upstream: ${upstreamVal} ${upstreamData.unit} at ${upstreamData.distance}m`);
@@ -167,31 +170,31 @@ console.log(`Upstream: ${upstreamVal} ${upstreamData.unit} at ${upstreamData.dis
 const downstreamVal = basicContainer
   .type('pressure')
   .variant('measured')
-  .position('downstream')
+  .position(POSITIONS.DOWNSTREAM)
   .getCurrentValue();
 
 const downstreamData = basicContainer
   .type('pressure')
   .variant('measured')
-  .position('downstream')
+  .position(POSITIONS.DOWNSTREAM)
   .get();
 
   //check wether a serie exists
-const hasSeries = basicContainer
+const hasSeries = basicContainer // eslint-disable-line no-unused-vars
   .type("flow")
   .variant("measured")
   .exists();                // true if any position exists
 
-const hasUpstreamValues = basicContainer
+const hasUpstreamValues = basicContainer // eslint-disable-line no-unused-vars
   .type("flow")
   .variant("measured")
-  .exists({ position: "upstream", requireValues: true });
+  .exists({ position: POSITIONS.UPSTREAM, requireValues: true });
 
 // Passing everything explicitly
-const hasPercent = basicContainer.exists({
+const hasPercent = basicContainer.exists({ // eslint-disable-line no-unused-vars
   type: "volume",
   variant: "percent",
-  position: "atEquipment",
+  position: POSITIONS.AT_EQUIPMENT,
 });
 
 
@@ -205,7 +208,7 @@ console.log('--- Example 6: Calculations & Statistics ---');
 basicContainer
   .type('flow')
   .variant('predicted')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .distance(3.0)
   .value(200)
   .unit('gpm');
@@ -213,7 +216,7 @@ basicContainer
 basicContainer
   .type('flow')
   .variant('predicted')
-  .position('downstream')
+  .position(POSITIONS.DOWNSTREAM)
   .distance(8.5)
   .value(195)
   .unit('gpm');
@@ -221,7 +224,7 @@ basicContainer
 const flowAvg = basicContainer
   .type('flow')
   .variant('predicted')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .getAverage();
 
 console.log(`Average upstream flow: ${flowAvg.toFixed(1)} gpm`);
@@ -234,8 +237,8 @@ const pressureDiff = basicContainer
 console.log(`Pressure difference: ${pressureDiff.value} ${pressureDiff.unit}\n`);
 
 //reversable difference
-const deltaP = basicContainer.type("pressure").variant("measured").difference(); // defaults to downstream - upstream
-const netFlow = basicContainer.type("flow").variant("measured").difference({ from: "upstream", to: "downstream" });
+const deltaP = basicContainer.type("pressure").variant("measured").difference(); // eslint-disable-line no-unused-vars -- defaults to downstream - upstream
+const netFlow = basicContainer.type("flow").variant("measured").difference({ from: POSITIONS.UPSTREAM, to: POSITIONS.DOWNSTREAM }); // eslint-disable-line no-unused-vars
 
 // ====================================
 // ADVANCED STATISTICS & HISTORY
@@ -245,7 +248,7 @@ console.log('--- Example 7: Advanced Statistics & History ---');
 basicContainer
   .type('flow')
   .variant('measured')
-  .position('upstream')
+  .position(POSITIONS.UPSTREAM)
   .distance(3.0)
   .value(210)
   .value(215)
@@ -257,7 +260,7 @@ basicContainer
 const stats = basicContainer
   .type('flow')
   .variant('measured')
-  .position('upstream');
+  .position(POSITIONS.UPSTREAM);
 
 const statsData = stats.get();
 

src/menu/index.js

@@ -1,5 +1,5 @@
 const AssetMenu = require('./asset.js');
-const { TagcodeApp, DynamicAssetMenu } = require('./tagcodeApp.js');
+// TagcodeApp and DynamicAssetMenu available via ./tagcodeApp.js
 const LoggerMenu = require('./logger.js');
 const PhysicalPositionMenu = require('./physicalPosition.js');
 const AquonSamplesMenu = require('./aquonSamples.js');

src/predict/interpolation.js

@@ -88,7 +88,7 @@ class Interpolation {
   array_values(obj) {
     const new_array = [];
     for (let i in obj) {
-      if (obj.hasOwnProperty(i)) {
+      if (Object.prototype.hasOwnProperty.call(obj, i)) {
         new_array.push(obj[i]);
       }
     }
@@ -101,6 +101,7 @@ class Interpolation {
     } else if (type == "monotone_cubic_spline") {
       this.monotonic_cubic_spline();
     } else if (type == "linear") {
+      /* intentionally empty */
     } else {
       this.error = 1000;
     }
@@ -230,7 +231,6 @@ class Interpolation {
     let xdata = this.input_xdata;
     let ydata = this.input_ydata;
 
-    let interpolationtype = this.interpolationtype;
     let tension = this.tension;
 
     let n = ydata.length;
@@ -266,6 +266,7 @@ class Interpolation {
     let k = 0;
 
     if (xpoint < xdata[0] || xpoint > xdata[n - 1]) {
+      /* intentionally empty */
     }
 
     while (k < n - 1 && xpoint > xdata[k + 1] && !(xpoint < xdata[0] || xpoint > xdata[n - 1])) {

src/predict/predict_class.js

@@ -161,6 +161,11 @@ class Predict {
     //find index of y peak
     const { peak , peakIndex } = this.getLocalPeak(curve.y);
 
+    // Guard against invalid peakIndex (e.g. empty array returns -1)
+    if (peakIndex < 0 || peakIndex >= curve.x.length) {
+      return { yPeak: null, x: null, xProcent: null };
+    }
+
     // scale the x value to procentual value
     const yPeak = peak;
     const x = curve.x[peakIndex];

src/state/movementManager.js

@@ -49,15 +49,17 @@ class movementManager {
     try {
       // Execute the movement logic based on the mode
       switch (this.movementMode) {
-        case "staticspeed":
+        case "staticspeed": {
           const movelinFeedback = await this.moveLinear(targetPosition,signal);
           this.logger.info(`Linear move: ${movelinFeedback} `);
           break;
+        }
 
-        case "dynspeed":
+        case "dynspeed": {
           const moveDynFeedback = await this.moveEaseInOut(targetPosition,signal);
           this.logger.info(`Dynamic move : ${moveDynFeedback}`);
           break;
+        }
 
         default:
           throw new Error(`Unsupported movement mode: ${this.movementMode}`);
@@ -211,7 +213,6 @@ class movementManager {
         return reject(new Error("Movement aborted"));
       }
 
-      const direction = targetPosition > this.currentPosition ? 1 : -1;
       const totalDistance = Math.abs(targetPosition - this.currentPosition);
       const startPosition = this.currentPosition;
       const velocity = this.getVelocity();

test/childRegistration.test.js

@@ -0,0 +1,360 @@
+const ChildRegistrationUtils = require('../src/helper/childRegistrationUtils');
+const { POSITIONS } = require('../src/constants/positions');
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/** Create a minimal mock parent (mainClass) that ChildRegistrationUtils expects. */
+function createMockParent(opts = {}) {
+  return {
+    child: {},
+    logger: {
+      debug: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+    },
+    // optionally provide a registerChild callback so the utils can delegate
+    registerChild: opts.registerChild || undefined,
+    ...opts,
+  };
+}
+
+/** Create a minimal mock child node with the given overrides. */
+function createMockChild(overrides = {}) {
+  const defaults = {
+    config: {
+      general: {
+        id: overrides.id || 'child-1',
+        name: overrides.name || 'TestChild',
+      },
+      functionality: {
+        softwareType: overrides.softwareType !== undefined ? overrides.softwareType : 'measurement',
+        positionVsParent: overrides.position || POSITIONS.UPSTREAM,
+      },
+      asset: {
+        category: overrides.category || 'sensor',
+        type: overrides.assetType || 'pressure',
+      },
+    },
+    measurements: overrides.measurements || null,
+  };
+  // allow caller to add extra top-level props
+  return { ...defaults, ...(overrides.extra || {}) };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('ChildRegistrationUtils', () => {
+  let parent;
+  let utils;
+
+  beforeEach(() => {
+    parent = createMockParent();
+    utils = new ChildRegistrationUtils(parent);
+  });
+
+  // ── Construction ─────────────────────────────────────────────────────────
+  describe('constructor', () => {
+    it('should store a reference to the mainClass', () => {
+      expect(utils.mainClass).toBe(parent);
+    });
+
+    it('should initialise with an empty registeredChildren map', () => {
+      expect(utils.registeredChildren.size).toBe(0);
+    });
+
+    it('should use the parent logger', () => {
+      expect(utils.logger).toBe(parent.logger);
+    });
+  });
+
+  // ── registerChild ────────────────────────────────────────────────────────
+  describe('registerChild()', () => {
+    it('should register a child and store it in the internal map', async () => {
+      const child = createMockChild();
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      expect(utils.registeredChildren.size).toBe(1);
+      expect(utils.registeredChildren.has('child-1')).toBe(true);
+    });
+
+    it('should store softwareType, position and timestamp in the registry entry', async () => {
+      const child = createMockChild({ softwareType: 'machine' });
+      const before = Date.now();
+      await utils.registerChild(child, POSITIONS.DOWNSTREAM);
+      const after = Date.now();
+
+      const entry = utils.registeredChildren.get('child-1');
+      expect(entry.softwareType).toBe('machine');
+      expect(entry.position).toBe(POSITIONS.DOWNSTREAM);
+      expect(entry.registeredAt).toBeGreaterThanOrEqual(before);
+      expect(entry.registeredAt).toBeLessThanOrEqual(after);
+    });
+
+    it('should store the child in mainClass.child[softwareType][category]', async () => {
+      const child = createMockChild({ softwareType: 'measurement', category: 'sensor' });
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      expect(parent.child.measurement).toBeDefined();
+      expect(parent.child.measurement.sensor).toBeInstanceOf(Array);
+      expect(parent.child.measurement.sensor).toContain(child);
+    });
+
+    it('should set the parent reference on the child', async () => {
+      const child = createMockChild();
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      expect(child.parent).toEqual([parent]);
+    });
+
+    it('should set positionVsParent on the child', async () => {
+      const child = createMockChild();
+      await utils.registerChild(child, POSITIONS.DOWNSTREAM);
+
+      expect(child.positionVsParent).toBe(POSITIONS.DOWNSTREAM);
+    });
+
+    it('should lowercase the softwareType before storing', async () => {
+      const child = createMockChild({ softwareType: 'Measurement' });
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      const entry = utils.registeredChildren.get('child-1');
+      expect(entry.softwareType).toBe('measurement');
+      expect(parent.child.measurement).toBeDefined();
+    });
+
+    it('should delegate to mainClass.registerChild when it is a function', async () => {
+      const registerSpy = jest.fn();
+      parent.registerChild = registerSpy;
+      const child = createMockChild({ softwareType: 'measurement' });
+
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      expect(registerSpy).toHaveBeenCalledWith(child, 'measurement');
+    });
+
+    it('should NOT throw when mainClass has no registerChild method', async () => {
+      delete parent.registerChild;
+      const child = createMockChild();
+
+      await expect(utils.registerChild(child, POSITIONS.UPSTREAM)).resolves.not.toThrow();
+    });
+
+    it('should log a debug message on registration', async () => {
+      const child = createMockChild({ name: 'Pump1', id: 'p1' });
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      expect(parent.logger.debug).toHaveBeenCalledWith(
+        expect.stringContaining('Registering child: Pump1')
+      );
+    });
+
+    it('should handle empty softwareType gracefully', async () => {
+      const child = createMockChild({ softwareType: '' });
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      const entry = utils.registeredChildren.get('child-1');
+      expect(entry.softwareType).toBe('');
+    });
+  });
+
+  // ── Multiple children ────────────────────────────────────────────────────
+  describe('multiple children registration', () => {
+    it('should register multiple children of the same softwareType', async () => {
+      const c1 = createMockChild({ id: 'c1', name: 'Sensor1', softwareType: 'measurement' });
+      const c2 = createMockChild({ id: 'c2', name: 'Sensor2', softwareType: 'measurement' });
+
+      await utils.registerChild(c1, POSITIONS.UPSTREAM);
+      await utils.registerChild(c2, POSITIONS.DOWNSTREAM);
+
+      expect(utils.registeredChildren.size).toBe(2);
+      expect(parent.child.measurement.sensor).toHaveLength(2);
+    });
+
+    it('should register children of different softwareTypes', async () => {
+      const sensor = createMockChild({ id: 's1', softwareType: 'measurement' });
+      const machine = createMockChild({ id: 'm1', softwareType: 'machine', category: 'pump' });
+
+      await utils.registerChild(sensor, POSITIONS.UPSTREAM);
+      await utils.registerChild(machine, POSITIONS.AT_EQUIPMENT);
+
+      expect(parent.child.measurement).toBeDefined();
+      expect(parent.child.machine).toBeDefined();
+      expect(parent.child.machine.pump).toContain(machine);
+    });
+
+    it('should register children of different categories under the same softwareType', async () => {
+      const sensor = createMockChild({ id: 's1', softwareType: 'measurement', category: 'sensor' });
+      const analyser = createMockChild({ id: 'a1', softwareType: 'measurement', category: 'analyser' });
+
+      await utils.registerChild(sensor, POSITIONS.UPSTREAM);
+      await utils.registerChild(analyser, POSITIONS.DOWNSTREAM);
+
+      expect(parent.child.measurement.sensor).toHaveLength(1);
+      expect(parent.child.measurement.analyser).toHaveLength(1);
+    });
+
+    it('should support multiple parents on a child (array append)', async () => {
+      const parent2 = createMockParent();
+      const utils2 = new ChildRegistrationUtils(parent2);
+      const child = createMockChild();
+
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+      await utils2.registerChild(child, POSITIONS.DOWNSTREAM);
+
+      expect(child.parent).toEqual([parent, parent2]);
+    });
+  });
+
+  // ── Duplicate registration ───────────────────────────────────────────────
+  describe('duplicate registration', () => {
+    it('should overwrite the registry entry when the same child id is registered twice', async () => {
+      const child = createMockChild({ id: 'dup-1' });
+
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+      await utils.registerChild(child, POSITIONS.DOWNSTREAM);
+
+      // Map.set overwrites, so still size 1
+      expect(utils.registeredChildren.size).toBe(1);
+      const entry = utils.registeredChildren.get('dup-1');
+      expect(entry.position).toBe(POSITIONS.DOWNSTREAM);
+    });
+
+    it('should push the child into the category array again on duplicate registration', async () => {
+      const child = createMockChild({ id: 'dup-1' });
+
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      // _storeChild does a push each time
+      expect(parent.child.measurement.sensor).toHaveLength(2);
+    });
+  });
+
+  // ── Measurement context setup ────────────────────────────────────────────
+  describe('measurement context on child', () => {
+    it('should call setChildId, setChildName, setParentRef when child has measurements', async () => {
+      const measurements = {
+        setChildId: jest.fn(),
+        setChildName: jest.fn(),
+        setParentRef: jest.fn(),
+      };
+      const child = createMockChild({ id: 'mc-1', name: 'Sensor1', measurements });
+
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      expect(measurements.setChildId).toHaveBeenCalledWith('mc-1');
+      expect(measurements.setChildName).toHaveBeenCalledWith('Sensor1');
+      expect(measurements.setParentRef).toHaveBeenCalledWith(parent);
+    });
+
+    it('should skip measurement setup when child has no measurements object', async () => {
+      const child = createMockChild({ measurements: null });
+
+      // Should not throw
+      await expect(utils.registerChild(child, POSITIONS.UPSTREAM)).resolves.not.toThrow();
+    });
+  });
+
+  // ── getChildrenOfType ────────────────────────────────────────────────────
+  describe('getChildrenOfType()', () => {
+    beforeEach(async () => {
+      const s1 = createMockChild({ id: 's1', softwareType: 'measurement', category: 'sensor' });
+      const s2 = createMockChild({ id: 's2', softwareType: 'measurement', category: 'sensor' });
+      const a1 = createMockChild({ id: 'a1', softwareType: 'measurement', category: 'analyser' });
+      const m1 = createMockChild({ id: 'm1', softwareType: 'machine', category: 'pump' });
+
+      await utils.registerChild(s1, POSITIONS.UPSTREAM);
+      await utils.registerChild(s2, POSITIONS.DOWNSTREAM);
+      await utils.registerChild(a1, POSITIONS.UPSTREAM);
+      await utils.registerChild(m1, POSITIONS.AT_EQUIPMENT);
+    });
+
+    it('should return all children of a given softwareType', () => {
+      const measurements = utils.getChildrenOfType('measurement');
+      expect(measurements).toHaveLength(3);
+    });
+
+    it('should return children filtered by category', () => {
+      const sensors = utils.getChildrenOfType('measurement', 'sensor');
+      expect(sensors).toHaveLength(2);
+    });
+
+    it('should return empty array for unknown softwareType', () => {
+      expect(utils.getChildrenOfType('nonexistent')).toEqual([]);
+    });
+
+    it('should return empty array for unknown category', () => {
+      expect(utils.getChildrenOfType('measurement', 'nonexistent')).toEqual([]);
+    });
+  });
+
+  // ── getChildById ─────────────────────────────────────────────────────────
+  describe('getChildById()', () => {
+    it('should return the child by its id', async () => {
+      const child = createMockChild({ id: 'find-me' });
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      expect(utils.getChildById('find-me')).toBe(child);
+    });
+
+    it('should return null for unknown id', () => {
+      expect(utils.getChildById('does-not-exist')).toBeNull();
+    });
+  });
+
+  // ── getAllChildren ───────────────────────────────────────────────────────
+  describe('getAllChildren()', () => {
+    it('should return an empty array when no children registered', () => {
+      expect(utils.getAllChildren()).toEqual([]);
+    });
+
+    it('should return all registered child objects', async () => {
+      const c1 = createMockChild({ id: 'c1' });
+      const c2 = createMockChild({ id: 'c2' });
+      await utils.registerChild(c1, POSITIONS.UPSTREAM);
+      await utils.registerChild(c2, POSITIONS.DOWNSTREAM);
+
+      const all = utils.getAllChildren();
+      expect(all).toHaveLength(2);
+      expect(all).toContain(c1);
+      expect(all).toContain(c2);
+    });
+  });
+
+  // ── logChildStructure ───────────────────────────────────────────────────
+  describe('logChildStructure()', () => {
+    it('should log the child structure via debug', async () => {
+      const child = createMockChild({ id: 'log-1', name: 'LogChild' });
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      utils.logChildStructure();
+
+      expect(parent.logger.debug).toHaveBeenCalledWith(
+        'Current child structure:',
+        expect.any(String)
+      );
+    });
+  });
+
+  // ── _storeChild (internal) ──────────────────────────────────────────────
+  describe('_storeChild() internal behaviour', () => {
+    it('should create the child object on parent if it does not exist', async () => {
+      delete parent.child;
+      const child = createMockChild();
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      expect(parent.child).toBeDefined();
+      expect(parent.child.measurement.sensor).toContain(child);
+    });
+
+    it('should use "sensor" as default category when asset.category is absent', async () => {
+      const child = createMockChild();
+      // remove asset.category to trigger default
+      delete child.config.asset.category;
+      await utils.registerChild(child, POSITIONS.UPSTREAM);
+
+      expect(parent.child.measurement.sensor).toContain(child);
+    });
+  });
+});

test/configManager.test.js

@@ -0,0 +1,217 @@
+const path = require('path');
+const ConfigManager = require('../src/configs/index');
+
+describe('ConfigManager', () => {
+  const configDir = path.resolve(__dirname, '../src/configs');
+  let cm;
+
+  beforeEach(() => {
+    cm = new ConfigManager(configDir);
+  });
+
+  // ── getConfig() ──────────────────────────────────────────────────────
+  describe('getConfig()', () => {
+    it('should load and parse a known JSON config file', () => {
+      const config = cm.getConfig('baseConfig');
+      expect(config).toBeDefined();
+      expect(typeof config).toBe('object');
+    });
+
+    it('should return the same content on successive calls', () => {
+      const a = cm.getConfig('baseConfig');
+      const b = cm.getConfig('baseConfig');
+      expect(a).toEqual(b);
+    });
+
+    it('should throw when the config file does not exist', () => {
+      expect(() => cm.getConfig('nonExistentConfig_xyz'))
+        .toThrow(/Failed to load config/);
+    });
+
+    it('should throw a descriptive message including the config name', () => {
+      expect(() => cm.getConfig('missing'))
+        .toThrow("Failed to load config 'missing'");
+    });
+  });
+
+  // ── hasConfig() ──────────────────────────────────────────────────────
+  describe('hasConfig()', () => {
+    it('should return true for a config that exists', () => {
+      expect(cm.hasConfig('baseConfig')).toBe(true);
+    });
+
+    it('should return false for a config that does not exist', () => {
+      expect(cm.hasConfig('doesNotExist_abc')).toBe(false);
+    });
+  });
+
+  // ── getAvailableConfigs() ────────────────────────────────────────────
+  describe('getAvailableConfigs()', () => {
+    it('should return an array of strings', () => {
+      const configs = cm.getAvailableConfigs();
+      expect(Array.isArray(configs)).toBe(true);
+      configs.forEach(name => expect(typeof name).toBe('string'));
+    });
+
+    it('should include known config names without .json extension', () => {
+      const configs = cm.getAvailableConfigs();
+      expect(configs).toContain('baseConfig');
+      expect(configs).toContain('diffuser');
+      expect(configs).toContain('measurement');
+    });
+
+    it('should not include .json extension in returned names', () => {
+      const configs = cm.getAvailableConfigs();
+      configs.forEach(name => {
+        expect(name).not.toMatch(/\.json$/);
+      });
+    });
+
+    it('should throw when pointed at a non-existent directory', () => {
+      const bad = new ConfigManager('/tmp/nonexistent_dir_xyz_123');
+      expect(() => bad.getAvailableConfigs()).toThrow(/Failed to read config directory/);
+    });
+  });
+
+  // ── buildConfig() ────────────────────────────────────────────────────
+  describe('buildConfig()', () => {
+    it('should return an object with general and functionality sections', () => {
+      const uiConfig = { name: 'TestNode', unit: 'bar', enableLog: true, logLevel: 'debug' };
+      const result = cm.buildConfig('measurement', uiConfig, 'node-id-1');
+      expect(result).toHaveProperty('general');
+      expect(result).toHaveProperty('functionality');
+      expect(result).toHaveProperty('output');
+    });
+
+    it('should populate general.name from uiConfig.name', () => {
+      const uiConfig = { name: 'MySensor' };
+      const result = cm.buildConfig('measurement', uiConfig, 'id-1');
+      expect(result.general.name).toBe('MySensor');
+    });
+
+    it('should default general.name to nodeName when uiConfig.name is empty', () => {
+      const result = cm.buildConfig('measurement', {}, 'id-1');
+      expect(result.general.name).toBe('measurement');
+    });
+
+    it('should set general.id from the nodeId argument', () => {
+      const result = cm.buildConfig('valve', {}, 'node-42');
+      expect(result.general.id).toBe('node-42');
+    });
+
+    it('should default unit to unitless', () => {
+      const result = cm.buildConfig('valve', {}, 'id-1');
+      expect(result.general.unit).toBe('unitless');
+    });
+
+    it('should default logging.enabled to true when enableLog is undefined', () => {
+      const result = cm.buildConfig('valve', {}, 'id-1');
+      expect(result.general.logging.enabled).toBe(true);
+    });
+
+    it('should respect enableLog = false', () => {
+      const result = cm.buildConfig('valve', { enableLog: false }, 'id-1');
+      expect(result.general.logging.enabled).toBe(false);
+    });
+
+    it('should default logLevel to info', () => {
+      const result = cm.buildConfig('valve', {}, 'id-1');
+      expect(result.general.logging.logLevel).toBe('info');
+    });
+
+    it('should set functionality.softwareType to lowercase nodeName', () => {
+      const result = cm.buildConfig('Valve', {}, 'id-1');
+      expect(result.functionality.softwareType).toBe('valve');
+    });
+
+    it('should default positionVsParent to atEquipment', () => {
+      const result = cm.buildConfig('valve', {}, 'id-1');
+      expect(result.functionality.positionVsParent).toBe('atEquipment');
+    });
+
+    it('should set distance when hasDistance is true', () => {
+      const result = cm.buildConfig('valve', { hasDistance: true, distance: 5.5 }, 'id-1');
+      expect(result.functionality.distance).toBe(5.5);
+    });
+
+    it('should set distance to undefined when hasDistance is false', () => {
+      const result = cm.buildConfig('valve', { hasDistance: false, distance: 5.5 }, 'id-1');
+      expect(result.functionality.distance).toBeUndefined();
+    });
+
+    // ── asset section ──────────────────────────────────────────────────
+    it('should not include asset section when no asset fields provided', () => {
+      const result = cm.buildConfig('valve', {}, 'id-1');
+      expect(result.asset).toBeUndefined();
+    });
+
+    it('should include asset section when supplier is provided', () => {
+      const result = cm.buildConfig('valve', { supplier: 'Siemens' }, 'id-1');
+      expect(result.asset).toBeDefined();
+      expect(result.asset.supplier).toBe('Siemens');
+    });
+
+    it('should populate asset defaults for missing optional fields', () => {
+      const result = cm.buildConfig('valve', { supplier: 'ABB' }, 'id-1');
+      expect(result.asset.category).toBe('sensor');
+      expect(result.asset.type).toBe('Unknown');
+      expect(result.asset.model).toBe('Unknown');
+    });
+
+    // ── domainConfig merge ─────────────────────────────────────────────
+    it('should merge domainConfig sections into the result', () => {
+      const domain = { scaling: { enabled: true, factor: 2 } };
+      const result = cm.buildConfig('measurement', {}, 'id-1', domain);
+      expect(result.scaling).toEqual({ enabled: true, factor: 2 });
+    });
+
+    it('should handle empty domainConfig gracefully', () => {
+      const result = cm.buildConfig('measurement', {}, 'id-1', {});
+      expect(result).toHaveProperty('general');
+      expect(result).toHaveProperty('functionality');
+    });
+
+    it('should default output formats to process and influxdb', () => {
+      const result = cm.buildConfig('measurement', {}, 'id-1');
+      expect(result.output).toEqual({
+        process: 'process',
+        dbase: 'influxdb',
+      });
+    });
+
+    it('should allow output format overrides from ui config', () => {
+      const result = cm.buildConfig('measurement', {
+        processOutputFormat: 'json',
+        dbaseOutputFormat: 'csv',
+      }, 'id-1');
+      expect(result.output).toEqual({
+        process: 'json',
+        dbase: 'csv',
+      });
+    });
+  });
+
+  // ── createEndpoint() ─────────────────────────────────────────────────
+  describe('createEndpoint()', () => {
+    it('should return a JavaScript string containing the node name', () => {
+      const script = cm.createEndpoint('baseConfig');
+      expect(typeof script).toBe('string');
+      expect(script).toContain('baseConfig');
+      expect(script).toContain('window.EVOLV');
+    });
+
+    it('should throw for a non-existent config', () => {
+      expect(() => cm.createEndpoint('doesNotExist_xyz'))
+        .toThrow(/Failed to create endpoint/);
+    });
+  });
+
+  // ── getBaseConfig() ──────────────────────────────────────────────────
+  describe('getBaseConfig()', () => {
+    it('should load the baseConfig.json file', () => {
+      const base = cm.getBaseConfig();
+      expect(base).toBeDefined();
+      expect(typeof base).toBe('object');
+    });
+  });
+});

test/measurementContainer.test.js

@@ -0,0 +1,336 @@
+const MeasurementContainer = require('../src/measurements/MeasurementContainer');
+
+describe('MeasurementContainer', () => {
+  let mc;
+
+  beforeEach(() => {
+    mc = new MeasurementContainer({ windowSize: 5, autoConvert: false });
+  });
+
+  // ── Construction ─────────────────────────────────────────────────────
+  describe('constructor', () => {
+    it('should initialise with default windowSize when none provided', () => {
+      const m = new MeasurementContainer();
+      expect(m.windowSize).toBe(10);
+    });
+
+    it('should accept a custom windowSize', () => {
+      expect(mc.windowSize).toBe(5);
+    });
+
+    it('should start with an empty measurements map', () => {
+      expect(mc.measurements).toEqual({});
+    });
+
+    it('should populate default units', () => {
+      expect(mc.defaultUnits.pressure).toBe('mbar');
+      expect(mc.defaultUnits.flow).toBe('m3/h');
+    });
+
+    it('should allow overriding default units', () => {
+      const m = new MeasurementContainer({ defaultUnits: { pressure: 'Pa' } });
+      expect(m.defaultUnits.pressure).toBe('Pa');
+    });
+  });
+
+  // ── Chainable setters ───────────────────────────────────────────────
+  describe('chaining API — type / variant / position', () => {
+    it('should set type and return this for chaining', () => {
+      const ret = mc.type('pressure');
+      expect(ret).toBe(mc);
+      expect(mc._currentType).toBe('pressure');
+    });
+
+    it('should reset variant and position when type is called', () => {
+      mc.type('pressure').variant('measured').position('upstream');
+      mc.type('flow');
+      expect(mc._currentVariant).toBeNull();
+      expect(mc._currentPosition).toBeNull();
+    });
+
+    it('should set variant and return this', () => {
+      mc.type('pressure');
+      const ret = mc.variant('measured');
+      expect(ret).toBe(mc);
+      expect(mc._currentVariant).toBe('measured');
+    });
+
+    it('should throw if variant is called without type', () => {
+      expect(() => mc.variant('measured')).toThrow(/Type must be specified/);
+    });
+
+    it('should set position (lowercased) and return this', () => {
+      mc.type('pressure').variant('measured');
+      const ret = mc.position('Upstream');
+      expect(ret).toBe(mc);
+      expect(mc._currentPosition).toBe('upstream');
+    });
+
+    it('should throw if position is called without variant', () => {
+      mc.type('pressure');
+      expect(() => mc.position('upstream')).toThrow(/Variant must be specified/);
+    });
+  });
+
+  // ── Storing and retrieving values ───────────────────────────────────
+  describe('value() and retrieval methods', () => {
+    beforeEach(() => {
+      mc.type('pressure').variant('measured').position('upstream');
+    });
+
+    it('should store a value and retrieve it with getCurrentValue()', () => {
+      mc.value(42, 1000);
+      expect(mc.getCurrentValue()).toBe(42);
+    });
+
+    it('should return this for chaining from value()', () => {
+      const ret = mc.value(1, 1000);
+      expect(ret).toBe(mc);
+    });
+
+    it('should store multiple values and keep the latest', () => {
+      mc.value(10, 1).value(20, 2).value(30, 3);
+      expect(mc.getCurrentValue()).toBe(30);
+    });
+
+    it('should respect the windowSize (rolling window)', () => {
+      for (let i = 1; i <= 8; i++) {
+        mc.value(i, i);
+      }
+      const all = mc.getAllValues();
+      // windowSize is 5, so only the last 5 values should remain
+      expect(all.values.length).toBe(5);
+      expect(all.values).toEqual([4, 5, 6, 7, 8]);
+    });
+
+    it('should compute getAverage() correctly', () => {
+      mc.value(10, 1).value(20, 2).value(30, 3);
+      expect(mc.getAverage()).toBe(20);
+    });
+
+    it('should compute getMin()', () => {
+      mc.value(10, 1).value(5, 2).value(20, 3);
+      expect(mc.getMin()).toBe(5);
+    });
+
+    it('should compute getMax()', () => {
+      mc.value(10, 1).value(5, 2).value(20, 3);
+      expect(mc.getMax()).toBe(20);
+    });
+
+    it('should return null for getCurrentValue() when no values exist', () => {
+      expect(mc.getCurrentValue()).toBeNull();
+    });
+
+    it('should return null for getAverage() when no values exist', () => {
+      expect(mc.getAverage()).toBeNull();
+    });
+
+    it('should return null for getMin() when no values exist', () => {
+      expect(mc.getMin()).toBeNull();
+    });
+
+    it('should return null for getMax() when no values exist', () => {
+      expect(mc.getMax()).toBeNull();
+    });
+  });
+
+  // ── getAllValues() ──────────────────────────────────────────────────
+  describe('getAllValues()', () => {
+    it('should return values, timestamps, and unit', () => {
+      mc.type('pressure').variant('measured').position('upstream');
+      mc.unit('bar');
+      mc.value(10, 100).value(20, 200);
+      const all = mc.getAllValues();
+      expect(all.values).toEqual([10, 20]);
+      expect(all.timestamps).toEqual([100, 200]);
+      expect(all.unit).toBe('bar');
+    });
+
+    it('should return null when chain is incomplete', () => {
+      mc.type('pressure');
+      expect(mc.getAllValues()).toBeNull();
+    });
+  });
+
+  // ── unit() ──────────────────────────────────────────────────────────
+  describe('unit()', () => {
+    it('should set unit on the underlying measurement', () => {
+      mc.type('pressure').variant('measured').position('upstream');
+      mc.unit('bar');
+      const measurement = mc.get();
+      expect(measurement.unit).toBe('bar');
+    });
+  });
+
+  // ── get() ───────────────────────────────────────────────────────────
+  describe('get()', () => {
+    it('should return the Measurement instance for a complete chain', () => {
+      mc.type('pressure').variant('measured').position('upstream');
+      mc.value(1, 1);
+      const m = mc.get();
+      expect(m).toBeDefined();
+      expect(m.type).toBe('pressure');
+      expect(m.variant).toBe('measured');
+      expect(m.position).toBe('upstream');
+    });
+
+    it('should return null when chain is incomplete', () => {
+      mc.type('pressure');
+      expect(mc.get()).toBeNull();
+    });
+  });
+
+  // ── exists() ────────────────────────────────────────────────────────
+  describe('exists()', () => {
+    it('should return false for a non-existent measurement', () => {
+      mc.type('pressure').variant('measured').position('upstream');
+      expect(mc.exists()).toBe(false);
+    });
+
+    it('should return true after a value has been stored', () => {
+      mc.type('pressure').variant('measured').position('upstream').value(1, 1);
+      expect(mc.exists()).toBe(true);
+    });
+
+    it('should support requireValues option', () => {
+      mc.type('pressure').variant('measured').position('upstream');
+      // Force creation of measurement without values
+      mc.get();
+      expect(mc.exists({ requireValues: false })).toBe(true);
+      expect(mc.exists({ requireValues: true })).toBe(false);
+    });
+
+    it('should support explicit type/variant/position overrides', () => {
+      mc.type('pressure').variant('measured').position('upstream').value(1, 1);
+      // Reset chain, then query by explicit keys
+      mc.type('flow');
+      expect(mc.exists({ type: 'pressure', variant: 'measured', position: 'upstream' })).toBe(true);
+      expect(mc.exists({ type: 'flow', variant: 'measured', position: 'upstream' })).toBe(false);
+    });
+
+    it('should return false when type is not set and not provided', () => {
+      const fresh = new MeasurementContainer({ autoConvert: false });
+      expect(fresh.exists()).toBe(false);
+    });
+  });
+
+  // ── getLaggedValue() / getLaggedSample() ─────────────────────────────
+  describe('getLaggedValue() and getLaggedSample()', () => {
+    beforeEach(() => {
+      mc.type('pressure').variant('measured').position('upstream');
+      mc.value(10, 100).value(20, 200).value(30, 300);
+    });
+
+    it('should return the value at lag=1 (previous value)', () => {
+      expect(mc.getLaggedValue(1)).toBe(20);
+    });
+
+    it('should return null when lag exceeds stored values', () => {
+      expect(mc.getLaggedValue(10)).toBeNull();
+    });
+
+    it('should return a sample object from getLaggedSample()', () => {
+      const sample = mc.getLaggedSample(0);
+      expect(sample).toHaveProperty('value', 30);
+      expect(sample).toHaveProperty('timestamp', 300);
+    });
+
+    it('should return null from getLaggedSample when not enough values', () => {
+      expect(mc.getLaggedSample(10)).toBeNull();
+    });
+  });
+
+  // ── Listing helpers ─────────────────────────────────────────────────
+  describe('getTypes() / getVariants() / getPositions()', () => {
+    beforeEach(() => {
+      mc.type('pressure').variant('measured').position('upstream').value(1, 1);
+      mc.type('flow').variant('predicted').position('downstream').value(2, 2);
+    });
+
+    it('should list all stored types', () => {
+      const types = mc.getTypes();
+      expect(types).toContain('pressure');
+      expect(types).toContain('flow');
+    });
+
+    it('should list variants for a given type', () => {
+      mc.type('pressure');
+      expect(mc.getVariants()).toContain('measured');
+    });
+
+    it('should return empty array for type with no variants', () => {
+      mc.type('temperature');
+      expect(mc.getVariants()).toEqual([]);
+    });
+
+    it('should throw if getVariants() called without type', () => {
+      const fresh = new MeasurementContainer({ autoConvert: false });
+      expect(() => fresh.getVariants()).toThrow(/Type must be specified/);
+    });
+
+    it('should list positions for type+variant', () => {
+      mc.type('pressure').variant('measured');
+      expect(mc.getPositions()).toContain('upstream');
+    });
+
+    it('should throw if getPositions() called without type and variant', () => {
+      const fresh = new MeasurementContainer({ autoConvert: false });
+      expect(() => fresh.getPositions()).toThrow(/Type and variant must be specified/);
+    });
+  });
+
+  // ── clear() ─────────────────────────────────────────────────────────
+  describe('clear()', () => {
+    it('should reset all measurements and chain state', () => {
+      mc.type('pressure').variant('measured').position('upstream').value(1, 1);
+      mc.clear();
+      expect(mc.measurements).toEqual({});
+      expect(mc._currentType).toBeNull();
+      expect(mc._currentVariant).toBeNull();
+      expect(mc._currentPosition).toBeNull();
+    });
+  });
+
+  // ── Child context setters ───────────────────────────────────────────
+  describe('child context', () => {
+    it('should set childId and return this', () => {
+      expect(mc.setChildId('c1')).toBe(mc);
+      expect(mc.childId).toBe('c1');
+    });
+
+    it('should set childName and return this', () => {
+      expect(mc.setChildName('pump1')).toBe(mc);
+      expect(mc.childName).toBe('pump1');
+    });
+
+    it('should set parentRef and return this', () => {
+      const parent = { id: 'p1' };
+      expect(mc.setParentRef(parent)).toBe(mc);
+      expect(mc.parentRef).toBe(parent);
+    });
+  });
+
+  // ── Event emission ──────────────────────────────────────────────────
+  describe('event emission', () => {
+    it('should emit an event when a value is set', (done) => {
+      mc.emitter.on('pressure.measured.upstream', (data) => {
+        expect(data.value).toBe(42);
+        expect(data.type).toBe('pressure');
+        expect(data.variant).toBe('measured');
+        expect(data.position).toBe('upstream');
+        done();
+      });
+      mc.type('pressure').variant('measured').position('upstream').value(42, 1);
+    });
+  });
+
+  // ── setPreferredUnit ────────────────────────────────────────────────
+  describe('setPreferredUnit()', () => {
+    it('should store preferred unit and return this', () => {
+      const ret = mc.setPreferredUnit('pressure', 'Pa');
+      expect(ret).toBe(mc);
+      expect(mc.preferredUnits.pressure).toBe('Pa');
+    });
+  });
+});

test/outputUtils.test.js

@@ -0,0 +1,69 @@
+const OutputUtils = require('../src/helper/outputUtils');
+
+describe('OutputUtils', () => {
+  let outputUtils;
+  let config;
+
+  beforeEach(() => {
+    outputUtils = new OutputUtils();
+    config = {
+      general: {
+        name: 'Pump-1',
+        id: 'node-1',
+        unit: 'm3/h',
+      },
+      functionality: {
+        softwareType: 'pump',
+        role: 'test-role',
+      },
+      asset: {
+        supplier: 'EVOLV',
+        type: 'sensor',
+      },
+      output: {
+        process: 'process',
+        dbase: 'influxdb',
+      },
+    };
+  });
+
+  it('keeps legacy process output by default', () => {
+    const msg = outputUtils.formatMsg({ flow: 12.5 }, config, 'process');
+    expect(msg).toEqual({
+      topic: 'Pump-1',
+      payload: { flow: 12.5 },
+    });
+  });
+
+  it('keeps legacy influxdb output by default', () => {
+    const msg = outputUtils.formatMsg({ flow: 12.5 }, config, 'influxdb');
+    expect(msg.topic).toBe('Pump-1');
+    expect(msg.payload).toEqual(expect.objectContaining({
+      measurement: 'Pump-1',
+      fields: { flow: 12.5 },
+      tags: expect.objectContaining({
+        id: 'node-1',
+        name: 'Pump-1',
+        softwareType: 'pump',
+      }),
+    }));
+  });
+
+  it('supports config-driven json formatting on the process channel', () => {
+    config.output.process = 'json';
+    const msg = outputUtils.formatMsg({ flow: 12.5 }, config, 'process');
+    expect(msg.topic).toBe('Pump-1');
+    expect(typeof msg.payload).toBe('string');
+    expect(msg.payload).toContain('"measurement":"Pump-1"');
+    expect(msg.payload).toContain('"flow":12.5');
+  });
+
+  it('supports config-driven csv formatting on the database channel', () => {
+    config.output.dbase = 'csv';
+    const msg = outputUtils.formatMsg({ flow: 12.5 }, config, 'influxdb');
+    expect(msg.topic).toBe('Pump-1');
+    expect(typeof msg.payload).toBe('string');
+    expect(msg.payload).toContain('Pump-1');
+    expect(msg.payload).toContain('flow=12.5');
+  });
+});

test/validationUtils.test.js

@@ -0,0 +1,554 @@
+const ValidationUtils = require('../src/helper/validationUtils');
+const { validateNumber, validateInteger, validateBoolean, validateString, validateEnum } = require('../src/helper/validators/typeValidators');
+const { validateArray, validateSet, validateObject } = require('../src/helper/validators/collectionValidators');
+const { validateCurve, validateMachineCurve, isSorted, isUnique, areNumbers } = require('../src/helper/validators/curveValidator');
+
+// Shared mock logger used across tests
+function mockLogger() {
+  return { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() };
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Type validators
+// ═══════════════════════════════════════════════════════════════════════
+describe('typeValidators', () => {
+  let logger;
+  beforeEach(() => { logger = mockLogger(); });
+
+  // ── validateNumber ──────────────────────────────────────────────────
+  describe('validateNumber()', () => {
+    it('should accept a valid number', () => {
+      expect(validateNumber(42, {}, { default: 0 }, 'n', 'k', logger)).toBe(42);
+    });
+
+    it('should parse a string to a number', () => {
+      expect(validateNumber('3.14', {}, { default: 0 }, 'n', 'k', logger)).toBe(3.14);
+      expect(logger.warn).toHaveBeenCalled();
+    });
+
+    it('should return default when below min', () => {
+      expect(validateNumber(1, { min: 5 }, { default: 5 }, 'n', 'k', logger)).toBe(5);
+    });
+
+    it('should return default when above max', () => {
+      expect(validateNumber(100, { max: 50 }, { default: 50 }, 'n', 'k', logger)).toBe(50);
+    });
+
+    it('should accept boundary value equal to min', () => {
+      expect(validateNumber(5, { min: 5 }, { default: 0 }, 'n', 'k', logger)).toBe(5);
+    });
+
+    it('should accept boundary value equal to max', () => {
+      expect(validateNumber(50, { max: 50 }, { default: 0 }, 'n', 'k', logger)).toBe(50);
+    });
+  });
+
+  // ── validateInteger ─────────────────────────────────────────────────
+  describe('validateInteger()', () => {
+    it('should accept a valid integer', () => {
+      expect(validateInteger(7, {}, { default: 0 }, 'n', 'k', logger)).toBe(7);
+    });
+
+    it('should parse a string to an integer', () => {
+      expect(validateInteger('10', {}, { default: 0 }, 'n', 'k', logger)).toBe(10);
+    });
+
+    it('should return default for a non-parseable value', () => {
+      expect(validateInteger('abc', {}, { default: -1 }, 'n', 'k', logger)).toBe(-1);
+    });
+
+    it('should return default when below min', () => {
+      expect(validateInteger(2, { min: 5 }, { default: 5 }, 'n', 'k', logger)).toBe(5);
+    });
+
+    it('should return default when above max', () => {
+      expect(validateInteger(100, { max: 50 }, { default: 50 }, 'n', 'k', logger)).toBe(50);
+    });
+
+    it('should parse a float string and truncate to integer', () => {
+      expect(validateInteger('7.9', {}, { default: 0 }, 'n', 'k', logger)).toBe(7);
+    });
+  });
+
+  // ── validateBoolean ─────────────────────────────────────────────────
+  describe('validateBoolean()', () => {
+    it('should pass through a true boolean', () => {
+      expect(validateBoolean(true, 'n', 'k', logger)).toBe(true);
+    });
+
+    it('should pass through a false boolean', () => {
+      expect(validateBoolean(false, 'n', 'k', logger)).toBe(false);
+    });
+
+    it('should parse string "true" to boolean true', () => {
+      expect(validateBoolean('true', 'n', 'k', logger)).toBe(true);
+    });
+
+    it('should parse string "false" to boolean false', () => {
+      expect(validateBoolean('false', 'n', 'k', logger)).toBe(false);
+    });
+
+    it('should pass through non-boolean non-string values unchanged', () => {
+      expect(validateBoolean(42, 'n', 'k', logger)).toBe(42);
+    });
+  });
+
+  // ── validateString ──────────────────────────────────────────────────
+  describe('validateString()', () => {
+    it('should accept a lowercase string', () => {
+      expect(validateString('hello', {}, { default: '' }, 'n', 'k', logger)).toBe('hello');
+    });
+
+    it('should convert uppercase to lowercase', () => {
+      expect(validateString('Hello', {}, { default: '' }, 'n', 'k', logger)).toBe('hello');
+    });
+
+    it('should convert a number to a string', () => {
+      expect(validateString(42, {}, { default: '' }, 'n', 'k', logger)).toBe('42');
+    });
+
+    it('should return null when nullable and value is null', () => {
+      expect(validateString(null, { nullable: true }, { default: '' }, 'n', 'k', logger)).toBeNull();
+    });
+  });
+
+  // ── validateEnum ────────────────────────────────────────────────────
+  describe('validateEnum()', () => {
+    const rules = { values: [{ value: 'open' }, { value: 'closed' }, { value: 'partial' }] };
+
+    it('should accept a valid enum value', () => {
+      expect(validateEnum('open', rules, { default: 'closed' }, 'n', 'k', logger)).toBe('open');
+    });
+
+    it('should be case-insensitive', () => {
+      expect(validateEnum('OPEN', rules, { default: 'closed' }, 'n', 'k', logger)).toBe('open');
+    });
+
+    it('should return default for an invalid value', () => {
+      expect(validateEnum('invalid', rules, { default: 'closed' }, 'n', 'k', logger)).toBe('closed');
+    });
+
+    it('should return default when value is null', () => {
+      expect(validateEnum(null, rules, { default: 'closed' }, 'n', 'k', logger)).toBe('closed');
+    });
+
+    it('should return default when rules.values is not an array', () => {
+      expect(validateEnum('open', {}, { default: 'closed' }, 'n', 'k', logger)).toBe('closed');
+    });
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Collection validators
+// ═══════════════════════════════════════════════════════════════════════
+describe('collectionValidators', () => {
+  let logger;
+  beforeEach(() => { logger = mockLogger(); });
+
+  // ── validateArray ───────────────────────────────────────────────────
+  describe('validateArray()', () => {
+    it('should return default when value is not an array', () => {
+      expect(validateArray('not-array', { itemType: 'number' }, { default: [1] }, 'n', 'k', logger))
+        .toEqual([1]);
+    });
+
+    it('should filter items by itemType', () => {
+      const result = validateArray([1, 'a', 2], { itemType: 'number', minLength: 1 }, { default: [] }, 'n', 'k', logger);
+      expect(result).toEqual([1, 2]);
+    });
+
+    it('should respect maxLength', () => {
+      const result = validateArray([1, 2, 3, 4, 5], { itemType: 'number', maxLength: 3, minLength: 1 }, { default: [] }, 'n', 'k', logger);
+      expect(result).toEqual([1, 2, 3]);
+    });
+
+    it('should return default when fewer items than minLength after filtering', () => {
+      const result = validateArray(['a'], { itemType: 'number', minLength: 1 }, { default: [0] }, 'n', 'k', logger);
+      expect(result).toEqual([0]);
+    });
+
+    it('should pass all items through when itemType is null', () => {
+      const result = validateArray([1, 'a', true], { itemType: 'null', minLength: 1 }, { default: [] }, 'n', 'k', logger);
+      expect(result).toEqual([1, 'a', true]);
+    });
+  });
+
+  // ── validateSet ─────────────────────────────────────────────────────
+  describe('validateSet()', () => {
+    it('should convert default to Set when value is not a Set', () => {
+      const result = validateSet('not-a-set', { itemType: 'number' }, { default: [1, 2] }, 'n', 'k', logger);
+      expect(result).toBeInstanceOf(Set);
+      expect([...result]).toEqual([1, 2]);
+    });
+
+    it('should filter Set items by type', () => {
+      const input = new Set([1, 'a', 2]);
+      const result = validateSet(input, { itemType: 'number', minLength: 1 }, { default: [] }, 'n', 'k', logger);
+      expect([...result]).toEqual([1, 2]);
+    });
+
+    it('should return default Set when too few items remain', () => {
+      const input = new Set(['a']);
+      const result = validateSet(input, { itemType: 'number', minLength: 1 }, { default: [0] }, 'n', 'k', logger);
+      expect([...result]).toEqual([0]);
+    });
+  });
+
+  // ── validateObject ──────────────────────────────────────────────────
+  describe('validateObject()', () => {
+    it('should return default when value is not an object', () => {
+      expect(validateObject('str', {}, { default: { a: 1 } }, 'n', 'k', jest.fn(), logger))
+        .toEqual({ a: 1 });
+    });
+
+    it('should return default when value is an array', () => {
+      expect(validateObject([1, 2], {}, { default: {} }, 'n', 'k', jest.fn(), logger))
+        .toEqual({});
+    });
+
+    it('should return default when no schema is provided', () => {
+      expect(validateObject({ a: 1 }, {}, { default: { b: 2 } }, 'n', 'k', jest.fn(), logger))
+        .toEqual({ b: 2 });
+    });
+
+    it('should call validateSchemaFn when schema is provided', () => {
+      const mockFn = jest.fn().mockReturnValue({ validated: true });
+      const rules = { schema: { x: { default: 1 } } };
+      const result = validateObject({ x: 2 }, rules, {}, 'n', 'k', mockFn, logger);
+      expect(mockFn).toHaveBeenCalledWith({ x: 2 }, rules.schema, 'n.k');
+      expect(result).toEqual({ validated: true });
+    });
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Curve validators
+// ═══════════════════════════════════════════════════════════════════════
+describe('curveValidator', () => {
+  let logger;
+  beforeEach(() => { logger = mockLogger(); });
+
+  // ── Helper utilities ────────────────────────────────────────────────
+  describe('isSorted()', () => {
+    it('should return true for a sorted array', () => {
+      expect(isSorted([1, 2, 3, 4])).toBe(true);
+    });
+
+    it('should return false for an unsorted array', () => {
+      expect(isSorted([3, 1, 2])).toBe(false);
+    });
+
+    it('should return true for an empty array', () => {
+      expect(isSorted([])).toBe(true);
+    });
+
+    it('should return true for equal adjacent values', () => {
+      expect(isSorted([1, 1, 2])).toBe(true);
+    });
+  });
+
+  describe('isUnique()', () => {
+    it('should return true when all values are unique', () => {
+      expect(isUnique([1, 2, 3])).toBe(true);
+    });
+
+    it('should return false when duplicates exist', () => {
+      expect(isUnique([1, 2, 2])).toBe(false);
+    });
+  });
+
+  describe('areNumbers()', () => {
+    it('should return true for all numbers', () => {
+      expect(areNumbers([1, 2.5, -3])).toBe(true);
+    });
+
+    it('should return false when a non-number is present', () => {
+      expect(areNumbers([1, 'a', 3])).toBe(false);
+    });
+  });
+
+  // ── validateCurve ───────────────────────────────────────────────────
+  describe('validateCurve()', () => {
+    const defaultCurve = { line1: { x: [0, 1], y: [0, 1] } };
+
+    it('should return default when input is null', () => {
+      expect(validateCurve(null, defaultCurve, logger)).toEqual(defaultCurve);
+    });
+
+    it('should return default for an empty object', () => {
+      expect(validateCurve({}, defaultCurve, logger)).toEqual(defaultCurve);
+    });
+
+    it('should validate a correct curve', () => {
+      const curve = { line1: { x: [1, 2, 3], y: [10, 20, 30] } };
+      const result = validateCurve(curve, defaultCurve, logger);
+      expect(result.line1.x).toEqual([1, 2, 3]);
+      expect(result.line1.y).toEqual([10, 20, 30]);
+    });
+
+    it('should sort unsorted x values and reorder y accordingly', () => {
+      const curve = { line1: { x: [3, 1, 2], y: [30, 10, 20] } };
+      const result = validateCurve(curve, defaultCurve, logger);
+      expect(result.line1.x).toEqual([1, 2, 3]);
+      expect(result.line1.y).toEqual([10, 20, 30]);
+    });
+
+    it('should remove duplicate x values', () => {
+      const curve = { line1: { x: [1, 1, 2], y: [10, 11, 20] } };
+      const result = validateCurve(curve, defaultCurve, logger);
+      expect(result.line1.x).toEqual([1, 2]);
+      expect(result.line1.y.length).toBe(2);
+    });
+
+    it('should return default when y contains non-numbers', () => {
+      const curve = { line1: { x: [1, 2], y: ['a', 'b'] } };
+      expect(validateCurve(curve, defaultCurve, logger)).toEqual(defaultCurve);
+    });
+  });
+
+  // ── validateMachineCurve ────────────────────────────────────────────
+  describe('validateMachineCurve()', () => {
+    const defaultMC = {
+      nq: { line1: { x: [0, 1], y: [0, 1] } },
+      np: { line1: { x: [0, 1], y: [0, 1] } },
+    };
+
+    it('should return default when input is null', () => {
+      expect(validateMachineCurve(null, defaultMC, logger)).toEqual(defaultMC);
+    });
+
+    it('should return default when nq or np is missing', () => {
+      expect(validateMachineCurve({ nq: {} }, defaultMC, logger)).toEqual(defaultMC);
+    });
+
+    it('should validate a correct machine curve', () => {
+      const input = {
+        nq: { line1: { x: [1, 2], y: [10, 20] } },
+        np: { line1: { x: [1, 2], y: [5, 10] } },
+      };
+      const result = validateMachineCurve(input, defaultMC, logger);
+      expect(result.nq.line1.x).toEqual([1, 2]);
+      expect(result.np.line1.y).toEqual([5, 10]);
+    });
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// ValidationUtils class
+// ═══════════════════════════════════════════════════════════════════════
+describe('ValidationUtils', () => {
+  let vu;
+
+  beforeEach(() => {
+    vu = new ValidationUtils(true, 'error'); // suppress most logging noise
+  });
+
+  // ── constrain() ─────────────────────────────────────────────────────
+  describe('constrain()', () => {
+    it('should return value when within range', () => {
+      expect(vu.constrain(5, 0, 10)).toBe(5);
+    });
+
+    it('should clamp to min when value is below range', () => {
+      expect(vu.constrain(-5, 0, 10)).toBe(0);
+    });
+
+    it('should clamp to max when value is above range', () => {
+      expect(vu.constrain(15, 0, 10)).toBe(10);
+    });
+
+    it('should return min for boundary value equal to min', () => {
+      expect(vu.constrain(0, 0, 10)).toBe(0);
+    });
+
+    it('should return max for boundary value equal to max', () => {
+      expect(vu.constrain(10, 0, 10)).toBe(10);
+    });
+
+    it('should return min when value is not a number', () => {
+      expect(vu.constrain('abc', 0, 10)).toBe(0);
+    });
+
+    it('should return min when value is null', () => {
+      expect(vu.constrain(null, 0, 10)).toBe(0);
+    });
+
+    it('should return min when value is undefined', () => {
+      expect(vu.constrain(undefined, 0, 10)).toBe(0);
+    });
+  });
+
+  // ── validateSchema() ────────────────────────────────────────────────
+  describe('validateSchema()', () => {
+    it('should use default value when config key is missing', () => {
+      const schema = {
+        speed: { default: 100, rules: { type: 'number' } },
+      };
+      const result = vu.validateSchema({}, schema, 'test');
+      expect(result.speed).toBe(100);
+    });
+
+    it('should use provided value over default', () => {
+      const schema = {
+        speed: { default: 100, rules: { type: 'number' } },
+      };
+      const result = vu.validateSchema({ speed: 200 }, schema, 'test');
+      expect(result.speed).toBe(200);
+    });
+
+    it('should strip unknown keys from config', () => {
+      const schema = {
+        speed: { default: 100, rules: { type: 'number' } },
+      };
+      const config = { speed: 50, unknownKey: 'bad' };
+      const result = vu.validateSchema(config, schema, 'test');
+      expect(result.unknownKey).toBeUndefined();
+      expect(result.speed).toBe(50);
+    });
+
+    it('should validate number type with min/max', () => {
+      const schema = {
+        speed: { default: 10, rules: { type: 'number', min: 0, max: 100 } },
+      };
+      // within range
+      expect(vu.validateSchema({ speed: 50 }, schema, 'test').speed).toBe(50);
+      // below min -> default
+      expect(vu.validateSchema({ speed: -1 }, schema, 'test').speed).toBe(10);
+      // above max -> default
+      expect(vu.validateSchema({ speed: 101 }, schema, 'test').speed).toBe(10);
+    });
+
+    it('should validate boolean type', () => {
+      const schema = {
+        enabled: { default: true, rules: { type: 'boolean' } },
+      };
+      expect(vu.validateSchema({ enabled: false }, schema, 'test').enabled).toBe(false);
+      expect(vu.validateSchema({ enabled: 'true' }, schema, 'test').enabled).toBe(true);
+    });
+
+    it('should validate string type (lowercased)', () => {
+      const schema = {
+        mode: { default: 'auto', rules: { type: 'string' } },
+      };
+      expect(vu.validateSchema({ mode: 'Manual' }, schema, 'test').mode).toBe('manual');
+    });
+
+    it('should validate enum type', () => {
+      const schema = {
+        state: {
+          default: 'open',
+          rules: { type: 'enum', values: [{ value: 'open' }, { value: 'closed' }] },
+        },
+      };
+      expect(vu.validateSchema({ state: 'closed' }, schema, 'test').state).toBe('closed');
+      expect(vu.validateSchema({ state: 'invalid' }, schema, 'test').state).toBe('open');
+    });
+
+    it('should validate integer type', () => {
+      const schema = {
+        count: { default: 5, rules: { type: 'integer', min: 1, max: 100 } },
+      };
+      expect(vu.validateSchema({ count: 10 }, schema, 'test').count).toBe(10);
+      expect(vu.validateSchema({ count: '42' }, schema, 'test').count).toBe(42);
+    });
+
+    it('should validate array type', () => {
+      const schema = {
+        items: { default: [1, 2], rules: { type: 'array', itemType: 'number', minLength: 1 } },
+      };
+      expect(vu.validateSchema({ items: [3, 4, 5] }, schema, 'test').items).toEqual([3, 4, 5]);
+      expect(vu.validateSchema({ items: 'not-array' }, schema, 'test').items).toEqual([1, 2]);
+    });
+
+    it('should handle nested object with schema recursively', () => {
+      const schema = {
+        logging: {
+          rules: { type: 'object', schema: {
+            enabled: { default: true, rules: { type: 'boolean' } },
+            level: { default: 'info', rules: { type: 'string' } },
+          }},
+        },
+      };
+      const result = vu.validateSchema(
+        { logging: { enabled: false, level: 'Debug' } },
+        schema,
+        'test'
+      );
+      expect(result.logging.enabled).toBe(false);
+      expect(result.logging.level).toBe('debug');
+    });
+
+    it('should skip reserved keys (rules, description, schema)', () => {
+      const schema = {
+        rules: 'should be skipped',
+        description: 'should be skipped',
+        schema: 'should be skipped',
+        speed: { default: 10, rules: { type: 'number' } },
+      };
+      const result = vu.validateSchema({}, schema, 'test');
+      expect(result).not.toHaveProperty('rules');
+      expect(result).not.toHaveProperty('description');
+      expect(result).not.toHaveProperty('schema');
+      expect(result.speed).toBe(10);
+    });
+
+    it('should use default for unknown validation type', () => {
+      const schema = {
+        weird: { default: 'fallback', rules: { type: 'unknownType' } },
+      };
+      const result = vu.validateSchema({ weird: 'value' }, schema, 'test');
+      expect(result.weird).toBe('fallback');
+    });
+
+    it('should handle curve type', () => {
+      const schema = {
+        curve: {
+          default: { line1: { x: [0, 1], y: [0, 1] } },
+          rules: { type: 'curve' },
+        },
+      };
+      const validCurve = { line1: { x: [1, 2], y: [10, 20] } };
+      const result = vu.validateSchema({ curve: validCurve }, schema, 'test');
+      expect(result.curve.line1.x).toEqual([1, 2]);
+    });
+  });
+
+  // ── removeUnwantedKeys() ────────────────────────────────────────────
+  describe('removeUnwantedKeys()', () => {
+    it('should remove rules and description keys', () => {
+      const input = {
+        speed: { default: 10, rules: { type: 'number' }, description: 'Speed setting' },
+      };
+      const result = vu.removeUnwantedKeys(input);
+      expect(result.speed).toBe(10);
+    });
+
+    it('should recurse into nested objects', () => {
+      const input = {
+        logging: {
+          enabled: { default: true, rules: {} },
+          level: { default: 'info', description: 'Log level' },
+        },
+      };
+      const result = vu.removeUnwantedKeys(input);
+      expect(result.logging.enabled).toBe(true);
+      expect(result.logging.level).toBe('info');
+    });
+
+    it('should handle arrays', () => {
+      const input = [
+        { a: { default: 1, rules: {} } },
+        { b: { default: 2, description: 'x' } },
+      ];
+      const result = vu.removeUnwantedKeys(input);
+      expect(result[0].a).toBe(1);
+      expect(result[1].b).toBe(2);
+    });
+
+    it('should return primitives as-is', () => {
+      expect(vu.removeUnwantedKeys(42)).toBe(42);
+      expect(vu.removeUnwantedKeys('hello')).toBe('hello');
+      expect(vu.removeUnwantedKeys(null)).toBeNull();
+    });
+  });
+});