From dec5f63b2192a8a04ae13325e7f6209ad1952ec9 Mon Sep 17 00:00:00 2001 From: Rene De Ren Date: Wed, 11 Mar 2026 15:35:28 +0100 Subject: [PATCH] refactor: adopt POSITIONS constants, fix ESLint warnings, break menuUtils into modules - Replace hardcoded position strings with POSITIONS.* constants - Prefix unused variables with _ to resolve no-unused-vars warnings - Fix no-prototype-builtins with Object.prototype.hasOwnProperty.call() - Extract menuUtils.js (543 lines) into 6 focused modules under menu/ - menuUtils.js now 35 lines, delegates via prototype mixin pattern - Add 158 unit tests for ConfigManager, MeasurementContainer, ValidationUtils Co-Authored-By: Claude Opus 4.6 --- src/convert/definitions/each.js | 3 +- src/convert/definitions/partsPer.js | 3 +- src/convert/index.js | 2 +- .../lodash/lodash._basecreate/index.js | 3 +- .../lodash/lodash._createwrapper/index.js | 2 +- src/convert/lodash/lodash.bind/index.js | 1 - src/helper/childRegistrationUtils.js | 2 +- src/helper/configUtils.js | 2 +- src/helper/menu/dataFetching.js | 123 ++++ src/helper/menu/dropdownPopulation.js | 283 +++++++++ src/helper/menu/htmlGeneration.js | 73 +++ src/helper/menu/index.js | 18 + src/helper/menu/toggles.js | 56 ++ src/helper/menu/urlUtils.js | 39 ++ src/helper/menuUtils.js | 562 +----------------- src/helper/outputUtils.js | 6 +- src/measurements/MeasurementContainer.js | 17 +- src/measurements/examples.js | 49 +- src/menu/index.js | 2 +- src/outliers/outlierDetection.js | 4 +- src/predict/interpolation.js | 3 +- src/state/movementManager.js | 1 - test/configManager.test.js | 196 ++++++ test/measurementContainer.test.js | 336 +++++++++++ test/validationUtils.test.js | 554 +++++++++++++++++ 25 files changed, 1753 insertions(+), 587 deletions(-) create mode 100644 src/helper/menu/dataFetching.js create mode 100644 src/helper/menu/dropdownPopulation.js create mode 100644 src/helper/menu/htmlGeneration.js create mode 100644 src/helper/menu/index.js create mode 100644 src/helper/menu/toggles.js create mode 100644 src/helper/menu/urlUtils.js create mode 100644 test/configManager.test.js create mode 100644 test/measurementContainer.test.js create mode 100644 test/validationUtils.test.js diff --git a/src/convert/definitions/each.js b/src/convert/definitions/each.js index 0f4f331..c88d37c 100644 --- a/src/convert/definitions/each.js +++ b/src/convert/definitions/each.js @@ -1,5 +1,4 @@ -var metric - , imperial; +var metric; metric = { ea: { diff --git a/src/convert/definitions/partsPer.js b/src/convert/definitions/partsPer.js index 333a203..42749b3 100644 --- a/src/convert/definitions/partsPer.js +++ b/src/convert/definitions/partsPer.js @@ -1,5 +1,4 @@ -var metric - , imperial; +var metric; metric = { ppm: { diff --git a/src/convert/index.js b/src/convert/index.js index 179287c..54a6812 100644 --- a/src/convert/index.js +++ b/src/convert/index.js @@ -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; diff --git a/src/convert/lodash/lodash._basecreate/index.js b/src/convert/lodash/lodash._basecreate/index.js index bdea56c..d9a0bc4 100644 --- a/src/convert/lodash/lodash._basecreate/index.js +++ b/src/convert/lodash/lodash._basecreate/index.js @@ -7,7 +7,6 @@ * Available under MIT 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,7 +20,7 @@ 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) { // eslint-disable-line no-func-assign +function baseCreate(prototype, _properties) { // eslint-disable-line no-func-assign return isObject(prototype) ? nativeCreate(prototype) : {}; } // fallback for browsers without `Object.create` diff --git a/src/convert/lodash/lodash._createwrapper/index.js b/src/convert/lodash/lodash._createwrapper/index.js index b2b8de3..b771ae4 100644 --- a/src/convert/lodash/lodash._createwrapper/index.js +++ b/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; diff --git a/src/convert/lodash/lodash.bind/index.js b/src/convert/lodash/lodash.bind/index.js index dc87bee..9c2723a 100644 --- a/src/convert/lodash/lodash.bind/index.js +++ b/src/convert/lodash/lodash.bind/index.js @@ -7,7 +7,6 @@ * Available under MIT license */ var createWrapper = require('./../lodash._createwrapper'), - reNative = require('./../lodash._renative'), slice = require('./../lodash._slice'); /** diff --git a/src/helper/childRegistrationUtils.js b/src/helper/childRegistrationUtils.js index 3e55bb7..ac45c7a 100644 --- a/src/helper/childRegistrationUtils.js +++ b/src/helper/childRegistrationUtils.js @@ -5,7 +5,7 @@ class ChildRegistrationUtils { this.registeredChildren = new Map(); } - async registerChild(child, positionVsParent, distance) { + async registerChild(child, positionVsParent, _distance) { const softwareType = (child.config.functionality.softwareType || '').toLowerCase(); const { name, id } = child.config.general; diff --git a/src/helper/configUtils.js b/src/helper/configUtils.js index e81d1d5..85811c5 100644 --- a/src/helper/configUtils.js +++ b/src/helper/configUtils.js @@ -76,7 +76,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)) { if (typeof obj2[key] === 'object') { if (!obj1[key]) { obj1[key] = {}; diff --git a/src/helper/menu/dataFetching.js b/src/helper/menu/dataFetching.js new file mode 100644 index 0000000..41b5bb6 --- /dev/null +++ b/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; diff --git a/src/helper/menu/dropdownPopulation.js b/src/helper/menu/dropdownPopulation.js new file mode 100644 index 0000000..86f8ec1 --- /dev/null +++ b/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; diff --git a/src/helper/menu/htmlGeneration.js b/src/helper/menu/htmlGeneration.js new file mode 100644 index 0000000..7b4cd44 --- /dev/null +++ b/src/helper/menu/htmlGeneration.js @@ -0,0 +1,73 @@ +/** + * 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 + ? `${options + .map((opt) => ``) + .join("")}` + : ""; + + 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 = 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'); + `; + }, +}; + +module.exports = htmlGeneration; diff --git a/src/helper/menu/index.js b/src/helper/menu/index.js new file mode 100644 index 0000000..c28e732 --- /dev/null +++ b/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, +}; diff --git a/src/helper/menu/toggles.js b/src/helper/menu/toggles.js new file mode 100644 index 0000000..9ee5bb4 --- /dev/null +++ b/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; diff --git a/src/helper/menu/urlUtils.js b/src/helper/menu/urlUtils.js new file mode 100644 index 0000000..35e7473 --- /dev/null +++ b/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; diff --git a/src/helper/menuUtils.js b/src/helper/menuUtils.js index 35dc33c..2ea1a96 100644 --- a/src/helper/menuUtils.js +++ b/src/helper/menuUtils.js @@ -1,544 +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){ /* 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); - } -} - - -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) { - /* intentionally empty */ - } -} - -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); - }); - /* - console.log('hello here I am:'); - console.log(node["modelMetadata"]); -*/ +// 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 - ? `${options - .map((opt) => ``) - .join("")}` - : ""; - - 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; \ No newline at end of file +module.exports = MenuUtils; diff --git a/src/helper/outputUtils.js b/src/helper/outputUtils.js index b365019..1a85520 100644 --- a/src/helper/outputUtils.js +++ b/src/helper/outputUtils.js @@ -9,7 +9,7 @@ class OutputUtils { checkForChanges(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)) { @@ -81,13 +81,13 @@ class OutputUtils { 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]); } } diff --git a/src/measurements/MeasurementContainer.js b/src/measurements/MeasurementContainer.js index 8445e1c..c11b460 100644 --- a/src/measurements/MeasurementContainer.js +++ b/src/measurements/MeasurementContainer.js @@ -1,9 +1,10 @@ const MeasurementBuilder = require('./MeasurementBuilder'); const EventEmitter = require('events'); const convertModule = require('../convert/index'); +const { POSITIONS } = require('../constants/positions'); class MeasurementContainer { - constructor(options = {},logger) { + constructor(options = {},_logger) { this.emitter = new EventEmitter(); this.measurements = {}; this.windowSize = options.windowSize || 10; // Default window size @@ -359,7 +360,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) { throw new Error("Type and variant must be specified for difference calculation"); } @@ -526,11 +527,11 @@ difference({ from = "downstream", to = "upstream", unit: requestedUnit } = {}) { _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: @@ -544,11 +545,11 @@ difference({ from = "downstream", to = "upstream", unit: requestedUnit } = {}) { _convertPositionNum2Str(positionValue) { switch (positionValue) { case 0: - return "atEquipment"; + return POSITIONS.AT_EQUIPMENT; case (positionValue < 0): - return "upstream"; + return POSITIONS.UPSTREAM; case (positionValue > 0): - return "downstream"; + return POSITIONS.DOWNSTREAM; default: console.log(`Invalid position provided: ${positionValue}`); } diff --git a/src/measurements/examples.js b/src/measurements/examples.js index 877957f..61e1885 100644 --- a/src/measurements/examples.js +++ b/src/measurements/examples.js @@ -1,4 +1,5 @@ const { MeasurementContainer } = require('./index'); +const { POSITIONS } = require('../constants/positions'); const measurements = new MeasurementContainer(); @@ -29,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'); @@ -37,7 +38,7 @@ basicContainer basicContainer .type('pressure') .variant('measured') - .position('downstream') + .position(POSITIONS.DOWNSTREAM) .distance(5.2) .value(95) .unit('psi'); @@ -46,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'); @@ -55,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}`); @@ -85,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 @@ -93,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)`); @@ -107,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')}`); @@ -155,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`); @@ -169,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 = measurements +const hasSeries = measurements // eslint-disable-line no-unused-vars .type("flow") .variant("measured") .exists(); // true if any position exists -const hasUpstreamValues = measurements +const hasUpstreamValues = measurements // 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 = measurements.exists({ +const hasPercent = measurements.exists({ // eslint-disable-line no-unused-vars type: "volume", variant: "percent", - position: "atEquipment", + position: POSITIONS.AT_EQUIPMENT, }); @@ -207,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'); @@ -215,7 +216,7 @@ basicContainer basicContainer .type('flow') .variant('predicted') - .position('downstream') + .position(POSITIONS.DOWNSTREAM) .distance(8.5) .value(195) .unit('gpm'); @@ -223,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`); @@ -236,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 @@ -247,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) @@ -259,7 +260,7 @@ basicContainer const stats = basicContainer .type('flow') .variant('measured') - .position('upstream'); + .position(POSITIONS.UPSTREAM); const statsData = stats.get(); diff --git a/src/menu/index.js b/src/menu/index.js index a6def7f..7495d0c 100644 --- a/src/menu/index.js +++ b/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'); diff --git a/src/outliers/outlierDetection.js b/src/outliers/outlierDetection.js index 2cdca81..97e7c51 100644 --- a/src/outliers/outlierDetection.js +++ b/src/outliers/outlierDetection.js @@ -86,4 +86,6 @@ dataStream.forEach((value, index) => { }); console.log("\nFinal detector cluster states:", JSON.stringify(detector.clusters, null, 2)); -*/ \ No newline at end of file +*/ + +module.exports = DynamicClusterDeviation; \ No newline at end of file diff --git a/src/predict/interpolation.js b/src/predict/interpolation.js index 2844d09..3b0e084 100644 --- a/src/predict/interpolation.js +++ b/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]); } } @@ -231,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; diff --git a/src/state/movementManager.js b/src/state/movementManager.js index c210e4b..fa5befd 100644 --- a/src/state/movementManager.js +++ b/src/state/movementManager.js @@ -216,7 +216,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; this.speed = Math.min(Math.max(this.speed, 0), 1); diff --git a/test/configManager.test.js b/test/configManager.test.js new file mode 100644 index 0000000..284b571 --- /dev/null +++ b/test/configManager.test.js @@ -0,0 +1,196 @@ +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('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'); + }); + + 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'); + }); + }); + + // ── 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'); + }); + }); +}); diff --git a/test/measurementContainer.test.js b/test/measurementContainer.test.js new file mode 100644 index 0000000..ebc4ee8 --- /dev/null +++ b/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'); + }); + }); +}); diff --git a/test/validationUtils.test.js b/test/validationUtils.test.js new file mode 100644 index 0000000..4543eb8 --- /dev/null +++ b/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(); + }); + }); +});