Add flowNumber configuration to define effluent flow handling

Reviewed-on: #1

LICENSE

@@ -1,9 +1,97 @@
-MIT License
+OPENBARE LICENTIE VAN DE EUROPESE UNIE v. 1.2. 
+EUPL © Europese Unie 2007, 2016 
+Deze openbare licentie van de Europese Unie („EUPL”) is van toepassing op het werk (zoals hieronder gedefinieerd) dat onder de voorwaarden van deze licentie wordt verstrekt. Elk gebruik van het werk dat niet door deze licentie is toegestaan, is verboden (voor zover dit gebruik valt onder een recht van de houder van het auteursrecht op het werk). Het werk wordt verstrekt onder de voorwaarden van deze licentie wanneer de licentiegever (zoals hieronder gedefinieerd), direct volgend op de kennisgeving inzake het auteursrecht op het werk, de volgende kennisgeving opneemt: 
+                  In licentie gegeven krachtens de EUPL 
+of op een andere wijze zijn bereidheid te kennen heeft gegeven krachtens de EUPL in licentie te geven. 
 
-Copyright (c) 2025 RnD
+1.Definities 
+In deze licentie wordt verstaan onder:  
+— „de licentie”:de onderhavige licentie;  
+— „het oorspronkelijke werk”:het werk dat of de software die door de licentiegever krachtens deze licentie wordt verspreid of medegedeeld, en dat/die beschikbaar is als broncode en, in voorkomend geval, ook als uitvoerbare code;  
+— „bewerkingen”:de werken of software die de licentiehouder kan creëren op grond van het oorspronkelijke werk of wijzigingen ervan. In deze licentie wordt niet gedefinieerd welke mate van wijziging of afhankelijkheid van het oorspronkelijke werk vereist is om een werk als een bewerking te kunnen aanmerken; dat wordt bepaald conform het auteursrecht dat van toepassing is in de in artikel 15 bedoelde staat;  
+— „het werk”:het oorspronkelijke werk of de bewerkingen ervan;  
+— „de broncode”:de voor mensen leesbare vorm van het werk, die het gemakkelijkste door mensen kan worden bestudeerd en gewijzigd;  
+— „de uitvoerbare code”:elke code die over het algemeen is gecompileerd en is bedoeld om door een computer als een programma te worden uitgevoerd;  
+— „de licentiegever”:de natuurlijke of rechtspersoon die het werk krachtens de licentie verspreidt of mededeelt;  
+— „bewerker(s)”:elke natuurlijke of rechtspersoon die het werk krachtens de licentie wijzigt of op een andere wijze bijdraagt tot de totstandkoming van een bewerking;  
+— „de licentiehouder” of „u”:elke natuurlijke of rechtspersoon die het werk onder de voorwaarden van de licentie gebruikt;  — „verspreiding” of „mededeling”:het verkopen, geven, uitlenen, verhuren, verspreiden, mededelen, doorgeven, of op een andere wijze online of offline beschikbaar stellen van kopieën van het werk of het verlenen van toegang tot de essentiële functies ervan ten behoeve van andere natuurlijke of rechtspersonen. 
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+2.Draagwijdte van de uit hoofde van de licentie verleende rechten 
+De licentiegever verleent u hierbij een wereldwijde, royaltyvrije, niet-exclusieve, voor een sublicentie in aanmerking komende licentie, om voor de duur van het aan het oorspronkelijke werk verbonden auteursrecht, het volgende te doen: 
+—  het werk in alle omstandigheden en voor ongeacht welk doel te gebruiken; 
+—  het werk te verveelvoudigen; 
+—  het werk te wijzigen en op grond van het werk bewerkingen te ontwikkelen; 
+—  het werk aan het publiek mede te delen, waaronder het recht om het werk of kopieën ervan aan het publiek ter beschikking te stellen of te vertonen, en het werk, in voorkomend geval, in het openbaar uit te voeren;
+—  het werk of kopieën ervan te verspreiden; 
+—  het werk of kopieën ervan uit te lenen en te verhuren; 
+—  de rechten op het werk of op kopieën ervan in sublicentie te geven. 
+Deze rechten kunnen worden uitgeoefend met gebruikmaking van alle thans bekende of nog uit te vinden media, dragers en formaten, voor zover het toepasselijke recht dit toestaat. In de landen waar immateriële rechten van toepassing zijn, doet de licentiegever afstand van zijn recht op uitoefening van zijn immateriële rechten in de mate die door het toepasselijke recht wordt toegestaan teneinde een doeltreffende uitoefening van de bovenvermelde in licentie gegeven economische rechten mogelijk te maken. De licentiegever verleent de licentiehouder een royaltyvrij, niet-exclusief gebruiksrecht op alle octrooien van de licentiegever, voor zover dit noodzakelijk is om de uit hoofde van deze licentie verleende rechten op het werk te gebruiken. 
 
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+3.Mededeling van de broncode 
+De licentiegever kan het werk verstrekken in zijn broncode of als uitvoerbare code. Indien het werk als uitvoerbare code wordt verstrekt, verstrekt de licentiegever bij elke door hem verspreide kopie van het werk tevens een machinaal leesbare kopie van de broncode van het werk of geeft hij in een mededeling, volgende op de bij het werk gevoegde auteursrechtelijke kennisgeving, de plaats aan waar de broncode gemakkelijk en vrij toegankelijk is, zolang de licentiegever het werk blijft verspreiden of mededelen. 
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+4.Beperkingen van het auteursrecht 
+Geen enkele bepaling in deze licentie heeft ten doel de licentiehouder het recht te ontnemen een beroep te doen op een uitzondering op of een beperking van de exclusieve rechten van de rechthebbenden op het werk, of op de uitputting van die rechten of andere toepasselijke beperkingen daarvan. 
+
+5.Verplichtingen van de licentiehouder 
+De verlening van de bovenvermelde rechten is onderworpen aan een aantal aan de licentiehouder opgelegde beperkingen en verplichtingen. Het gaat om de onderstaande verplichtingen.
+
+Attributierecht: de licentiehouder moet alle auteurs-, octrooi- of merkenrechtelijke kennisgevingen onverlet laten alsook alle kennisgevingen die naar de licentie en de afwijzing van garanties verwijzen. De licentiehouder moet een afschrift van deze kennisgevingen en een afschrift van de licentie bij elke kopie van het werk voegen die hij verspreidt of mededeelt. De licentiehouder moet in elke bewerking duidelijk aangeven dat het werk is gewijzigd, en eveneens de datum van wijziging vermelden. 
+
+Copyleftclausule: wanneer de licentiehouder kopieën van het oorspronkelijke werk of bewerkingen verspreidt of mededeelt, geschiedt die verspreiding of mededeling onder de voorwaarden van deze licentie of van een latere versie van deze licentie, tenzij het oorspronkelijke werk uitdrukkelijk alleen onder deze versie van de licentie wordt verspreid — bijvoorbeeld door de mededeling „alleen EUPL v. 1.2”. De licentiehouder (die licentiegever wordt) kan met betrekking tot het werk of de bewerkingen geen aanvullende bepalingen of voorwaarden opleggen of stellen die de voorwaarden van de licentie wijzigen of beperken. 
+
+Verenigbaarheidsclausule: wanneer de licentiehouder bewerkingen of kopieën ervan verspreidt of mededeelt die zijn gebaseerd op het werk en op een ander werk dat uit hoofde van een verenigbare licentie in licentie is gegeven, kan die verspreiding of mededeling geschieden onder de voorwaarden van deze verenigbare licentie. Voor de toepassing van deze clausule wordt onder „verenigbare licentie” verstaan, de licenties die in het aanhangsel bij deze licentie zijn opgesomd. Indien de verplichtingen van de licentiehouder uit hoofde van de verenigbare licentie in strijd zijn met diens verplichtingen uit hoofde van deze licentie, hebben de verplichtingen van de verenigbare licentie voorrang. 
+
+Verstrekking van de broncode: bij de verspreiding of mededeling van kopieën van het werk verstrekt de licentiehouder een machinaal leesbare kopie van de broncode of geeft hij aan waar deze broncode gemakkelijk en vrij toegankelijk is, zolang de licentiehouder het werk blijft verspreiden of mededelen. 
+
+Juridische bescherming: deze licentie verleent geen toestemming om handelsnamen, handelsmerken, dienstmerken of namen van de licentiegever te gebruiken, behalve wanneer dit op grond van een redelijk en normaal gebruik noodzakelijk is om de oorsprong van het werk te beschrijven en de inhoud van de auteursrechtelijke kennisgeving te herhalen.
+
+6.Auteursketen 
+De oorspronkelijke licentiegever garandeert dat hij houder is van het hierbij verleende auteursrecht op het oorspronkelijke werk dan wel dat dit hem in licentie is gegeven en dat hij de bevoegdheid heeft de licentie te verlenen. Elke bewerker garandeert dat hij houder is van het auteursrecht op de door hem aan het werk aangebrachte wijzigingen dan wel dat dit hem in licentie is gegeven en dat hij de bevoegdheid heeft de licentie te verlenen. Telkens wanneer u de licentie aanvaardt, verlenen de oorspronkelijke licentiegever en de opeenvolgende bewerkers u een licentie op hun bijdragen aan het werk onder de voorwaarden van deze licentie. 
+
+7.Uitsluiting van garantie 
+Het werk is een werk in ontwikkeling, dat voortdurend door vele bewerkers wordt verbeterd. Het is een onvoltooid werk, dat bijgevolg nog tekortkomingen of programmeerfouten („bugs”) kan vertonen, die onlosmakelijk verbonden zijn met dit soort ontwikkeling. Om die reden wordt het werk op grond van de licentie verstrekt „zoals het is” en zonder enige garantie met betrekking tot het werk te geven, met inbegrip van, maar niet beperkt tot garanties met betrekking tot de verhandelbaarheid, de geschiktheid voor een specifiek doel, de afwezigheid van tekortkomingen of fouten, de nauwkeurigheid, de eerbiediging van andere intellectuele-eigendomsrechten dan het in artikel 6 van deze licentie bedoelde auteursrecht. Deze uitsluiting van garantie is een essentieel onderdeel van de licentie en een voorwaarde voor de verlening van rechten op het werk. 
+
+8.Uitsluiting van aansprakelijkheid 
+Behoudens in het geval van een opzettelijke fout of directe schade aan natuurlijke personen, is de licentiegever in geen enkel geval aansprakelijk voor ongeacht welke directe of indirecte, materiële of immateriële schade die voortvloeit uit de licentie of het gebruik van het werk, met inbegrip van, maar niet beperkt tot schade als gevolg van het verlies van goodwill, verloren werkuren, een computerdefect of computerfout, het verlies van gegevens, of enige andere commerciële schade, zelfs indien de licentiegever werd gewezen op de mogelijkheid van dergelijke schade. De licentiegever is echter aansprakelijk op grond van de wetgeving inzake productaansprakelijkheid, voor zover deze wetgeving op het werk van toepassing is. 
+
+9.Aanvullende overeenkomsten 
+Bij de verspreiding van het werk kunt u ervoor kiezen een aanvullende overeenkomst te sluiten, waarin de verplichtingen of diensten overeenkomstig deze licentie worden omschreven. Indien deze verplichtingen worden aanvaard, kunt u echter alleen in eigen naam en onder eigen verantwoordelijkheid handelen, en dus niet in naam van de oorspronkelijke licentiegever of een bewerker, en kunt u voorts alleen handelen indien u ermee instemt alle bewerkers schadeloos te stellen, te verdedigen of te vrijwaren met betrekking tot de aansprakelijkheid van of vorderingen tegen deze bewerkers op grond van het feit dat u een garantie of aanvullende aansprakelijkheid hebt aanvaard. 
+
+10.Aanvaarding van de licentie 
+De bepalingen van deze licentie kunnen worden aanvaard door te klikken op het pictogram „Ik ga akkoord”, dat zich bevindt onderaan het venster waarin de tekst van deze licentie is weergegeven, of door overeenkomstig de toepasselijke wetsbepalingen op een soortgelijke wijze met de licentie in te stemmen. Door op dat pictogram te klikken geeft u aan dat u deze licentie en alle voorwaarden ervan ondubbelzinnig en onherroepelijk aanvaardt. Evenzo aanvaardt u onherroepelijk deze licentie en alle voorwaarden ervan door uitoefening van de rechten die u in artikel 2 van deze licentie zijn verleend, zoals het gebruik van het werk, het creëren door u van een bewerking of de verspreiding of mededeling door u van het werk of kopieën ervan. 
+
+11.Voorlichting van het publiek 
+Indien u het werk verspreidt of mededeelt door middel van elektronische communicatiemiddelen (bijvoorbeeld door voor te stellen het werk op afstand te downloaden), moet het distributiekanaal of het medium (bijvoorbeeld een website) het publiek ten minste de gegevens verschaffen die door het toepasselijke recht zijn voorgeschreven met betrekking tot de licentiegever, de licentie en de wijze waarop deze kan worden geraadpleegd, gesloten, opgeslagen en gereproduceerd door de licentiehouder.
+
+12.Einde van de licentie 
+De licentie en de uit hoofde daarvan verleende rechten eindigen automatisch bij elke inbreuk door de licentiehouder op de voorwaarden van de licentie. Dit einde beëindigt niet de licenties van personen die het werk van de licentiehouder krachtens de licentie hebben ontvangen, mits deze personen zich volledig aan de licentie houden. 
+
+13.Overige 
+Onverminderd artikel 9 vormt de licentie de gehele overeenkomst tussen de partijen met betrekking tot het werk. Indien een bepaling van de licentie volgens het toepasselijke recht ongeldig is of niet uitvoerbaar is, doet dit geen afbreuk aan de geldigheid of uitvoerbaarheid van de licentie in haar geheel. Deze bepaling dient zodanig te worden uitgelegd of gewijzigd dat zij geldig en uitvoerbaar wordt. De Europese Commissie kan, voor zover dit noodzakelijk en redelijk is, versies in andere talen of nieuwe versies van deze licentie of geactualiseerde versies van dit aanhangsel publiceren, zonder de draagwijdte van de uit hoofde van de licentie verleende rechten te beperken. Nieuwe versies van de licentie zullen worden gepubliceerd met een uniek versienummer. Alle door de Europese Commissie goedgekeurde taalversies van deze licentie hebben dezelfde waarde. De partijen kunnen zich beroepen op de taalversie van hun keuze. 
+
+14.Bevoegd gerecht
+Onverminderd specifieke overeenkomsten tussen de partijen, 
+—  vallen alle geschillen tussen de instellingen, organen en instanties van de Europese Unie, als licentiegeefster, en een licentiehouder in verband met de uitlegging van deze licentie onder de bevoegdheid van het Hof van Justitie van de Europese Unie, conform artikel 272 van het Verdrag betreffende de werking van de Europese Unie, 
+—  vallen alle geschillen tussen andere partijen in verband met de uitlegging van deze licentie onder de uitsluitende bevoegdheid van het bevoegde gerecht van de plaats waar de licentiegever is gevestigd of zijn voornaamste activiteit uitoefent. 
+
+15.Toepasselijk recht 
+Onverminderd specifieke overeenkomsten tussen de partijen, 
+—  wordt deze licentie beheerst door het recht van de lidstaat van de Europese Unie waar de licentiegever zijn statutaire zetel, verblijfplaats of hoofdkantoor heeft, 
+—  wordt deze licentie beheerst door het Belgische recht indien de licentiegever geen statutaire zetel, verblijfplaats of hoofdkantoor heeft in een lidstaat van de Europese Unie.
+
+   
+Aanhangsel 
+„Verenigbare licenties” in de zin van artikel 5 EUPL zijn: 
+—  GNU General Public License (GPL) v. 2, v. 3 
+—  GNU Affero General Public License (AGPL) v. 3 
+—  Open Software License (OSL) v. 2.1, v. 3.0 
+—  Eclipse Public License (EPL) v. 1.0 
+—  CeCILL v. 2.0, v. 2.1 
+—  Mozilla Public Licence (MPL) v. 2 
+—  GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3 
+—  Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) voor andere werken dan software 
+—  European Union Public Licence (EUPL) v. 1.1, v. 1.2 
+—  Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) of Strong Reciprocity (LiLiQ-R+).
+De Europese Commissie kan dit aanhangsel actualiseren in geval van latere versies van de bovengenoemde licenties zonder dat er een nieuwe EUPL-versie wordt ontwikkeld, zolang die versies de uit hoofde van artikel 2 van deze licentie verleende rechten verlenen en ze de betrokken broncode beschermen tegen exclusieve toe-eigening.
+Voor alle andere wijzigingen van of aanvullingen op dit aanhangsel is de ontwikkeling van een nieuwe EUPL-versie vereist.

datasets/assetData/assetData.json

@@ -0,0 +1,134 @@
+{
+  "suppliers": [
+    {
+      "name": "Vega",
+      "categories": [
+        {
+          "name": "Sensor",
+          "types": [
+            {
+              "name": "Temperature",
+              "models": [
+                { 
+                  "name": "VegaTemp 10",
+                  "units": ["°C", "°F"]
+                },
+                { 
+                  "name": "VegaTemp 20", 
+                  "units": ["°C", "°F"]
+                }
+              ]
+            },
+            {
+              "name": "Pressure", 
+              "models": [
+                {
+                  "name": "VegaPressure 10",
+                  "units": ["bar", "mbar", "psi"]
+                },
+                { 
+                  "name": "VegaPressure 20", 
+                  "units": ["bar", "mbar", "psi"]
+                }
+              ]
+            },
+            {
+              "name": "Flow",
+              "models": [
+                { 
+                  "name": "VegaFlow 10", 
+                  "units": ["m³/h", "gpm", "l/min"]
+                },
+                { 
+                  "name": "VegaFlow 20", 
+                  "units": ["m³/h", "gpm", "l/min"]
+                }
+              ]
+            },
+            {
+              "name": "Level",
+              "models": [
+                { 
+                  "name": "VegaLevel 10", 
+                  "units": ["m", "ft", "mm"]
+                },
+                { 
+                  "name": "VegaLevel 20", 
+                  "units": ["m", "ft", "mm"]
+                }
+              ]
+            },
+            {
+              "name": "Quantity (oxygen)",
+              "models": [
+                { 
+                  "name": "VegaOxySense 10", 
+                  "units": ["g/m³", "mol/m³"]
+                }
+              ]
+            },
+            {
+              "name": "Quantity (TSS)",
+              "models": [
+                { 
+                  "name": "VegaSolidsProbe", 
+                  "units": ["g/m³"]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "name": "Hidrostal",
+      "categories": [
+        {
+          "name": "Pumps",
+          "types": [
+            {
+              "name": "Centrifugal",
+              "models": [
+                { 
+                  "id": "hidrostal-pump-001",
+                  "name": "hidrostal-H05K-S03R",
+                  "units": ["m³/h", "gpm", "l/min"]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "name": "Binder Engineering",
+      "categories": [
+        {
+          "name": "Valves",
+          "types": [
+            {
+              "name": "Gate",
+              "models": [
+                {
+                  "id": "binder-valve-001",
+                  "name": "ECDV",
+                  "units": ["m³/h", "gpm", "l/min"]
+                }
+              ]
+            },
+            {
+              "name": "Jet",
+              "models": [
+                {
+                  "id": "binder-valve-002",
+                  "name": "JCV",
+                  "units": ["m³/h", "gpm", "l/min"]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

datasets/assetData/curves/ECDV.json

@@ -0,0 +1,16 @@
+{
+    "1.204": {
+        "125": {
+            "x": [0,10,20,30,40,50,60,70,80,90,100],
+            "y": [0,18,50,95,150,216,337,564,882,1398,1870]
+        },
+        "150": {
+            "x": [0,10,20,30,40,50,60,70,80,90,100],
+            "y": [0,25,73,138,217,314,490,818,1281,2029,2715]
+        },
+        "400": {
+            "x": [0,10,20,30,40,50,60,70,80,90,100],
+            "y": [0,155,443,839,1322,1911,2982,4980,7795,12349,16524]
+        }
+    }
+}

datasets/assetData/curves/index.js

@@ -0,0 +1,124 @@
+const fs = require('fs');
+const path = require('path');
+
+class AssetLoader {
+  constructor() {
+    this.relPath = './'
+    this.baseDir = path.resolve(__dirname, this.relPath);
+    this.cache = new Map(); // Cache loaded JSON files for better performance
+  }
+
+  /**
+   * Load a specific curve by type
+   * @param {string} curveType - The curve identifier (e.g., 'hidrostal-H05K-S03R')
+   * @returns {Object|null} The curve data object or null if not found
+   */
+  loadCurve(curveType) {
+    return this.loadAsset('curves', curveType);
+  }
+
+  /**
+   * Load any asset from a specific dataset folder
+   * @param {string} datasetType - The dataset folder name (e.g., 'curves', 'assetData')
+   * @param {string} assetId - The specific asset identifier
+   * @returns {Object|null} The asset data object or null if not found
+   */
+  loadAsset(datasetType, assetId) {
+    //const cacheKey = `${datasetType}/${assetId}`;
+    const cacheKey = `${assetId}`;
+
+    
+    // Check cache first
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    try {
+      const filePath = path.join(this.baseDir, `${assetId}.json`);
+
+      // Check if file exists
+      if (!fs.existsSync(filePath)) {
+        console.warn(`Asset not found: ${filePath}`);
+        return null;
+      }
+
+      // Load and parse JSON
+      const rawData = fs.readFileSync(filePath, 'utf8');
+      const assetData = JSON.parse(rawData);
+      
+      // Cache the result
+      this.cache.set(cacheKey, assetData);
+      
+      return assetData;
+    } catch (error) {
+      console.error(`Error loading asset ${cacheKey}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get all available assets in a dataset
+   * @param {string} datasetType - The dataset folder name
+   * @returns {string[]} Array of available asset IDs
+   */
+  getAvailableAssets(datasetType) {
+    try {
+      const datasetPath = path.join(this.baseDir, datasetType);
+      
+      if (!fs.existsSync(datasetPath)) {
+        return [];
+      }
+
+      return fs.readdirSync(datasetPath)
+        .filter(file => file.endsWith('.json'))
+        .map(file => file.replace('.json', ''));
+    } catch (error) {
+      console.error(`Error reading dataset ${datasetType}:`, error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Clear the cache (useful for development/testing)
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+// Create and export a singleton instance
+const assetLoader = new AssetLoader();
+
+module.exports = {
+  AssetLoader,
+  assetLoader,
+  // Convenience methods for backward compatibility
+  loadCurve: (curveType) => assetLoader.loadCurve(curveType),
+  loadAsset: (datasetType, assetId) => assetLoader.loadAsset(datasetType, assetId),
+  getAvailableAssets: (datasetType) => assetLoader.getAvailableAssets(datasetType)
+};
+
+/*
+// Example usage in your scripts
+const loader = new AssetLoader();
+
+// Load a specific curve
+const curve = loader.loadCurve('hidrostal-H05K-S03R');
+if (curve) {
+  console.log('Curve loaded:', curve);
+} else {
+  console.log('Curve not found');
+}
+/*
+// Load any asset from any dataset
+const someAsset = loadAsset('assetData', 'some-asset-id');
+
+// Get list of available curves
+const availableCurves = getAvailableAssets('curves');
+console.log('Available curves:', availableCurves);
+
+// Using the class directly for more control
+const { AssetLoader } = require('./index.js');
+const customLoader = new AssetLoader();
+const data = customLoader.loadCurve('hidrostal-H05K-S03R');
+*/

datasets/assetData/pumps/DAB/centrifugal pumps/models.json

@@ -1,36 +0,0 @@
-[
-    {
-        "name": "DAB Evosta 2 20-75",
-        "description": "N/A",
-        "machineCurve": {
-            "np": {
-                "200": {
-                    "x": [0, 20, 40, 60, 80, 100],
-                    "y": [5, 8, 12, 15, 17, 18]
-                },
-                "300": {
-                    "x": [0, 20, 40, 60, 80, 100],
-                    "y": [20, 28, 32, 34, 35, 35]
-                },
-                "400": {
-                    "x": [0, 20, 40, 60, 80, 100],
-                    "y": [35, 38, 42, 45, 47, 48]
-                }
-            },
-            "nq": {
-                "200": {
-                    "x": [0, 20, 40, 60, 80, 100],
-                    "y": [0, 0.4, 0.8, 1.2, 1.6, 2.0]
-                },
-                "300": {
-                    "x": [0, 20, 40, 60, 80, 100],
-                    "y": [0, 0.72, 1.44, 2.16, 2.88, 3.6]
-                },
-                "400": {
-                    "x": [0, 20, 40, 60, 80, 100],
-                    "y": [0, 0.8, 1.6, 2.4, 3.2, 4.0]
-                }
-            }
-        }
-    }
-]

datasets/assetData/pumps/DAB/subtypes.json

@@ -1,6 +0,0 @@
-[
-    {
-        "id": "1",
-        "name": "centrifugal pumps"
-    } 
-]

datasets/assetData/pumps/hydrostal/subtypes.json

@@ -1,6 +0,0 @@
-[
-    {
-        "id": "1",
-        "name": "centrifugal pumps"
-    } 
-]

datasets/assetData/pumps/suppliers.json

@@ -1,10 +0,0 @@
-[
-    {
-        "id": "1",
-        "name": "hydrostal"
-    },
-    {
-        "id": "2",
-        "name": "DAB"
-    }
-]

datasets/assetData/sensors/eastron/power/models.json

@@ -1,7 +0,0 @@
-[
-    {
-        "id": "1",
-        "name": "SDM120MODBUS",
-        "description": "De SDM120MODBUS kWh meter is een kWh meter die geschikt is voor het meten van zowel verbruik als teruglevering van stroom. Dat maakt deze meter ook zeer geschikt in combinatie met zonnepanelen."
-    }
-]

datasets/assetData/sensors/eastron/subTypes.json

@@ -1,6 +0,0 @@
-[
-    {
-        "id": "1",
-        "name": "power"
-    } 
-]

datasets/assetData/sensors/eh/flow/models.json

@@ -1,7 +0,0 @@
-[
-    {
-        "id": "1",
-        "name": "Proline Promag W 400",
-        "description": "A flow meter used for measuring the flow of liquids in various industrial applications."
-    }
-]

datasets/assetData/sensors/eh/subTypes.json

@@ -1,6 +0,0 @@
-[
-    {
-        "id": "1",
-        "name": "flow"
-    } 
-]

datasets/assetData/sensors/suppliers.json

@@ -1,14 +0,0 @@
-[
-    {
-        "id": "1",
-        "name": "vega"
-    },
-    {
-        "id": "2",
-        "name": "eh"
-    },
-    {
-        "id": "3",
-        "name": "eastron"
-    }
-]

datasets/assetData/sensors/vega/pressure/models.json

@@ -1,6 +0,0 @@
-[
-    {
-        "name": "Vegabar 14",
-        "description": "N/A"
-    }
-]

datasets/assetData/sensors/vega/subtypes.json

@@ -1,14 +0,0 @@
-[
-    {
-        "id": "1",
-        "name": "pressure"
-    },
-    {
-        "id": "2",
-        "name": "flow"
-    },
-    {
-        "id": "3",
-        "name": "temperature"
-    }
-]

datasets/assetData/sensors/vega/temperature/models.json

@@ -1,30 +0,0 @@
-[
-    {
-        "name": "VegaTemp 10",
-        "description": "Low cost sensor for general purpose applications."
-    },
-    {
-        "name": "VegaTemp 20",
-        "description": "High accuracy sensor for laboratory applications."
-    },
-    {
-        "name": "VegaTemp 30",
-        "description": "High accuracy sensor for industrial applications."
-    },
-    {
-        "name": "VegaTemp 40",
-        "description": "High accuracy sensor for environmental monitoring."
-    },
-    {
-        "name": "VegaTemp 50",
-        "description": "High accuracy temperature sensor for industrial applications."
-    },
-    {
-        "name": "VegaTherm 22",
-        "description": "Compact sensor ideal for environmental monitoring."
-    },
-    {
-        "name": "VegaTemp 100",
-        "description": "Robust sensor designed for high temperature ranges."
-    }
-]

datasets/tagcodeapp_product_models.json

@@ -0,0 +1,229 @@
+{
+    "success": true,
+    "message": "Product modellen succesvol opgehaald.",
+    "data": [
+        {
+            "id": "1",
+            "name": "Macbook Air 12",
+            "product_model_subtype_id": "1",
+            "product_model_description": null,
+            "vendor_id": "1",
+            "product_model_status": null,
+            "vendor_name": "Apple",
+            "product_subtype_name": "Laptop",
+            "product_model_meta": []
+        },
+        {
+            "id": "2",
+            "name": "Macbook Air 13",
+            "product_model_subtype_id": "1",
+            "product_model_description": null,
+            "vendor_id": "1",
+            "product_model_status": null,
+            "vendor_name": "Apple",
+            "product_subtype_name": "Laptop",
+            "product_model_meta": []
+        },
+        {
+            "id": "3",
+            "name": "AirMac 1 128 GB White",
+            "product_model_subtype_id": "2",
+            "product_model_description": null,
+            "vendor_id": "1",
+            "product_model_status": null,
+            "vendor_name": "Apple",
+            "product_subtype_name": "Desktop",
+            "product_model_meta": []
+        },
+        {
+            "id": "4",
+            "name": "AirMac 2 256 GB Black",
+            "product_model_subtype_id": "2",
+            "product_model_description": null,
+            "vendor_id": "1",
+            "product_model_status": null,
+            "vendor_name": "Apple",
+            "product_subtype_name": "Desktop",
+            "product_model_meta": []
+        },
+        {
+            "id": "5",
+            "name": "AirMac 2 256 GB White",
+            "product_model_subtype_id": "2",
+            "product_model_description": null,
+            "vendor_id": "1",
+            "product_model_status": null,
+            "vendor_name": "Apple",
+            "product_subtype_name": "Desktop",
+            "product_model_meta": []
+        },
+        {
+            "id": "6",
+            "name": "Vegabar 14",
+            "product_model_subtype_id": "3",
+            "product_model_description": "vegabar 14",
+            "vendor_id": "4",
+            "product_model_status": "Actief",
+            "vendor_name": "vega",
+            "product_subtype_name": "pressure",
+            "product_model_meta": {
+                "machineCurve": {
+                    "np": {
+                        "700": {
+                            "x": [
+                                0,
+                                24.59,
+                                49.18,
+                                73.77,
+                                100
+                            ],
+                            "y": [
+                                12.962460720759278,
+                                20.65443723573673,
+                                31.029351002816465,
+                                44.58926412111886,
+                                62.87460150792057
+                            ]
+                        },
+                        "800": {
+                            "x": [
+                                0,
+                                24.59,
+                                49.18,
+                                73.77,
+                                100
+                            ],
+                            "y": [
+                                13.035157335397209,
+                                20.74906989186132,
+                                31.029351002816465,
+                                44.58926412111886,
+                                62.87460150792057
+                            ]
+                        },
+                        "900": {
+                            "x": [
+                                0,
+                                24.59,
+                                49.18,
+                                73.77,
+                                100
+                            ],
+                            "y": [
+                                13.064663380158798,
+                                20.927197054134297,
+                                31.107126521989933,
+                                44.58926412111886,
+                                62.87460150792057
+                            ]
+                        },
+                        "1000": {
+                            "x": [
+                                0,
+                                24.59,
+                                49.18,
+                                73.77,
+                                100
+                            ],
+                            "y": [
+                                13.039271391128953,
+                                21.08680188366637,
+                                31.30899920405947,
+                                44.58926412111886,
+                                62.87460150792057
+                            ]
+                        },
+                        "1100": {
+                            "x": [
+                                0,
+                                24.59,
+                                49.18,
+                                73.77,
+                                100
+                            ],
+                            "y": [
+                                12.940075520572446,
+                                21.220547481589954,
+                                31.51468295656385,
+                                44.621326083982,
+                                62.87460150792057
+                            ]
+                        }
+                    },
+                    "nq": {
+                        "700": {
+                            "x": [
+                                0,
+                                24.59,
+                                49.18,
+                                73.77,
+                                100
+                            ],
+                            "y": [
+                                119.13938764447377,
+                                150.12178608265387,
+                                178.82698019104356,
+                                202.3699313222398,
+                                227.06382297856618
+                            ]
+                        },
+                        "800": {
+                            "x": [
+                                0,
+                                24.59,
+                                49.18,
+                                73.77,
+                                100
+                            ],
+                            "y": [
+                                112.59072109293984,
+                                148.15847460389205,
+                                178.82698019104356,
+                                202.3699313222398,
+                                227.06382297856618
+                            ]
+                        },
+                        "900": {
+                            "x": [
+                                0,
+                                24.59,
+                                49.18,
+                                73.77,
+                                100
+                            ],
+                            "y": [
+                                105.6217241180404,
+                                144.00502117747064,
+                                177.15212647335034,
+                                202.3699313222398,
+                                227.06382297856618
+                            ]
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "id": "7",
+            "name": "Vegabar 10",
+            "product_model_subtype_id": "3",
+            "product_model_description": null,
+            "vendor_id": "4",
+            "product_model_status": "Actief",
+            "vendor_name": "vega",
+            "product_subtype_name": "pressure",
+            "product_model_meta": []
+        },
+        {
+            "id": "8",
+            "name": "VegaFlow 10",
+            "product_model_subtype_id": "4",
+            "product_model_description": null,
+            "vendor_id": "4",
+            "product_model_status": "Actief",
+            "vendor_name": "vega",
+            "product_subtype_name": "flow",
+            "product_model_meta": []
+        }
+    ]
+}

helper/assetUtils.js

@@ -1,3 +0,0 @@
-export function getAssetVariables() {
-
-}

helper/configUtils.js

@@ -1,94 +0,0 @@
-/**
- * @file configUtils.js
- *
- * Permission is hereby granted to any person obtaining a copy of this software 
- * and associated documentation files (the "Software"), to use it for personal 
- * or non-commercial purposes, with the following restrictions:
- *
- * 1. **No Copying or Redistribution**: The Software or any of its parts may not 
- *    be copied, merged, distributed, sublicensed, or sold without explicit 
- *    prior written permission from the author.
- * 
- * 2. **Commercial Use**: Any use of the Software for commercial purposes requires 
- *    a valid license, obtainable only with the explicit consent of the author.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
- * FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER 
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, 
- * OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
- * SOFTWARE.
- *
- * Ownership of this code remains solely with the original author. Unauthorized 
- * use of this Software is strictly prohibited.
- *
- * @summary Utility for managing and validating configuration values.
- * @description Utility for managing and validating configuration values.
- * @module ConfigUtils
- * @requires ValidationUtils
- * @requires Logger
- * @exports ConfigUtils
- * @version 0.1.0
- * @since 0.1.0
- */
-
-
-const ValidationUtils = require("./validationUtils");
-const Logger = require("./logger");
-
-class ConfigUtils {
-    constructor(defaultConfig, IloggerEnabled , IloggerLevel) {
-        const loggerEnabled = IloggerEnabled || true;
-        const loggerLevel = IloggerLevel || "warn";
-        this.logger = new Logger(loggerEnabled, loggerLevel, 'ConfigUtils');
-        this.defaultConfig = defaultConfig;
-        this.validationUtils = new ValidationUtils(loggerEnabled, loggerLevel);
-    }
-
-    // Initialize configuration
-    initConfig(config) {
-        this.logger.info("Initializing configuration...");
-
-        // Validate the provided configuration
-        const validatedConfig = this.validationUtils.validateSchema(config, this.defaultConfig, this.defaultConfig.functionality.softwareType.default);
-
-        this.logger.info("Configuration initialized successfully.");
-
-        return validatedConfig;
-    }
-
-
-    // Update configuration
-    updateConfig(currentConfig, newConfig) {
-        this.logger.info("Updating configuration...");
-
-        // Merge 2 configs and validate the result
-        const mergedConfig = this.mergeObjects(currentConfig, newConfig);
-        
-        // Merge current configuration with new values
-        const updatedConfig = this.validationUtils.validateSchema(mergedConfig, this.defaultConfig, this.defaultConfig.functionality.softwareType.default);
-
-        this.logger.info("Configuration updated successfully.");
-        return updatedConfig;
-    }
-
-    // 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 (typeof obj2[key] === 'object') {
-                    if (!obj1[key]) {
-                        obj1[key] = {};
-                    }
-                    this.mergeObjects(obj1[key], obj2[key]);
-                } else {
-                    obj1[key] = obj2[key];
-                }
-            }
-        }
-        return obj1;
-    }
-}
-
-module.exports = ConfigUtils;

helper/logger.js

@@ -1,57 +0,0 @@
-class Logger {
-    constructor(logging = true, logLevel = 'debug', nameModule = 'N/A') {
-      this.logging = logging; // Boolean flag to enable/disable logging
-      this.logLevel = logLevel; // Default log level: 'debug', 'info', 'warn', 'error'
-      this.levels = ['debug', 'info', 'warn', 'error']; // Log levels in order of severity
-      this.nameModule = nameModule; // Name of the module that uses the logger
-    }
-  
-    // Helper function to check if a log message should be displayed based on current log level
-    shouldLog(level) {
-      return this.levels.indexOf(level) >= this.levels.indexOf(this.logLevel);
-    }
-  
-    // Log a debug message
-    debug(message) {
-      if (this.logging && this.shouldLog('debug')) {
-        console.debug(`[DEBUG] -> ${this.nameModule}: ${message}`);
-      }
-    }
-  
-    // Log an info message
-    info(message) {
-      if (this.logging && this.shouldLog('info')) {
-        console.info(`[INFO] -> ${this.nameModule}: ${message}`);
-      }
-    }
-  
-    // Log a warning message
-    warn(message) {
-      if (this.logging && this.shouldLog('warn')) {
-        console.warn(`[WARN] -> ${this.nameModule}: ${message}`);
-      }
-    }
-  
-    // Log an error message
-    error(message) {
-      if (this.logging && this.shouldLog('error')) {
-        console.error(`[ERROR] -> ${this.nameModule}: ${message}`);
-      }
-    }
-  
-    // Set the log level dynamically
-    setLogLevel(level) {
-      if (this.levels.includes(level)) {
-        this.logLevel = level;
-      } else {
-        console.error(`[ERROR ${nameModule}]: Invalid log level: ${level}`);
-      }
-    }
-  
-    // Toggle the logging on or off
-    toggleLogging() {
-      this.logging = !this.logging;
-    }
-  }
-  
-  module.exports = Logger;

helper/measurements/Measurement.js

@@ -1,187 +0,0 @@
-// Add unit conversion support
-const convertModule = require('../../../convert/dependencies/index');
-
-class Measurement {
-  constructor(type, variant, position, windowSize) {
-    this.type = type;               // e.g. 'pressure', 'flow', etc.
-    this.variant = variant;         // e.g. 'predicted' or 'measured', etc..
-    this.position = position;       // Downstream or upstream of parent object
-    this.windowSize = windowSize;   // Rolling window size
-
-    // Place all data inside an array
-    this.values = [];               // Array to store all values
-    this.timestamps = [];           // Array to store all timestamps
-    
-    // Unit tracking
-    this.unit = null;                // Current unit of measurement
-
-    // For tracking differences if this is a calculated difference measurement
-    this.isDifference = false;
-    this.sourcePositions = [];
-  }
-
-  // -- Updater methods --
-  setType(type) {
-    this.type = type;
-    return this;
-  }
-
-  setVariant(variant) {
-    this.variant = variant;
-    return this;
-  }
-
-  setPosition(position) {
-    this.position = position;
-    return this;
-  }
-
-  setValue(value, timestamp = Date.now()) {
-    /*
-    if (value === undefined || value === null) {
-      value = null ;
-      //throw new Error('Value cannot be null or undefined');
-    }
-    */
-
-    //shift the oldest value
-    if(this.values.length >= this.windowSize){
-      this.values.shift();
-      this.timestamps.shift();
-    }
-
-    //push the new value
-    this.values.push(value);
-    this.timestamps.push(timestamp);
-
-    return this;
-  }
-
-  setUnit(unit) {
-    this.unit = unit;
-    return this;
-  }
-  
-  // -- Getter methods --
-  getCurrentValue() {
-    if (this.values.length === 0) return null;
-    return this.values[this.values.length - 1];
-  }
-  
-  getAverage() {
-    if (this.values.length === 0) return null;
-    const sum = this.values.reduce((acc, val) => acc + val, 0);
-    return sum / this.values.length;
-  }
-  
-  getMin() {
-    if (this.values.length === 0) return null;
-    return Math.min(...this.values);
-  }
-  
-  getMax() {
-    if (this.values.length === 0) return null;
-    return Math.max(...this.values);
-  }
-  
-  getAllValues() {
-    return {
-      values: [...this.values],
-      timestamps: [...this.timestamps],
-      unit: this.unit
-    };
-  }
-  
-  // -- Position-based methods --
-  
-  // Create a new measurement that is the difference between two positions
-  static createDifference(upstreamMeasurement, downstreamMeasurement) {
-    console.log('hello:');
-    if (upstreamMeasurement.type !== downstreamMeasurement.type || 
-        upstreamMeasurement.variant !== downstreamMeasurement.variant) {
-      throw new Error('Cannot calculate difference between different measurement types or variants');
-    }
-    
-    // Ensure units match
-    let downstream = downstreamMeasurement;
-    if (upstreamMeasurement.unit && downstream.unit && 
-        upstreamMeasurement.unit !== downstream.unit) {
-      downstream = downstream.convertTo(upstreamMeasurement.unit);
-    }
-    
-    // Create a new difference measurement
-    const diffMeasurement = new Measurement(
-      upstreamMeasurement.type,
-      upstreamMeasurement.variant,
-      'difference',
-      Math.min(upstreamMeasurement.windowSize, downstream.windowSize)
-    );
-    
-    // Mark as a difference measurement and keep track of sources
-    diffMeasurement.isDifference = true;
-    diffMeasurement.sourcePositions = ['upstream', 'downstream'];
-    
-    // Calculate all differences where timestamps match
-    const upValues = upstreamMeasurement.getAllValues();
-    const downValues = downstream.getAllValues();
-    
-    // Match timestamps and calculate differences
-    for (let i = 0; i < upValues.timestamps.length; i++) {
-      const upTimestamp = upValues.timestamps[i];
-      const downIndex = downValues.timestamps.indexOf(upTimestamp);
-      
-      if (downIndex !== -1) {
-
-        const diff = upValues.values[i] - downValues.values[downIndex];
-        diffMeasurement.setValue(diff, upTimestamp);
-      }
-    }
-    
-    diffMeasurement.setUnit(upstreamMeasurement.unit);
-    
-    return diffMeasurement;
-  }
-  
-  // -- Additional getter methods --
-  getLatestTimestamp() {
-    if (this.timestamps.length === 0) return null;
-    return this.timestamps[this.timestamps.length - 1];
-  }
-  
-  getValueAtTimestamp(timestamp) {
-    const index = this.timestamps.indexOf(timestamp);
-    if (index === -1) return null;
-    return this.values[index];
-  }
-  
-  // -- Unit conversion methods --
-  convertTo(targetUnit) {
-    if (!this.unit) {
-      throw new Error('Current unit not set, cannot convert');
-    }
-    
-    try {
-      const convertedValues = this.values.map(value => 
-        convertModule.convert(value).from(this.unit).to(targetUnit)
-      );
-      
-      const newMeasurement = new Measurement(
-        this.type, 
-        this.variant, 
-        this.position,
-        this.windowSize
-      );
-      
-      // Copy values and timestamps
-      newMeasurement.values = convertedValues;
-      newMeasurement.timestamps = [...this.timestamps];
-      newMeasurement.unit = targetUnit;
-      
-      return newMeasurement;
-    } catch (error) {
-      throw new Error(`Unit conversion failed: ${error.message}`);
-    }
-  }
-}
-
-module.exports = Measurement;

helper/measurements/MeasurementBuilder.js

@@ -1,56 +0,0 @@
-const Measurement = require('./Measurement');
-
-class MeasurementBuilder {
-  constructor() {
-    this.type = null;
-    this.variant = null;
-    this.position = null;
-    this.windowSize = 10; // Default window size
-  }
-
-  // e.g. 'pressure', 'flow', etc.
-  setType(type) {
-    this.type = type;
-    return this;
-  }
-
-  // e.g. 'predicted' or 'measured', etc..
-  setVariant(variant) {
-    this.variant = variant;
-    return this;
-  }
-
-  // Downstream or upstream of parent object
-  setPosition(position) {
-    this.position = position;
-    return this;
-  }
-
-  // default size of the data that gets tracked
-  setWindowSize(windowSize) {
-    this.windowSize = windowSize;
-    return this;
-  }
-
-  build() {
-    // Validate required fields
-    if (!this.type) {
-      throw new Error('Measurement type is required');
-    }
-    if (!this.variant) {
-      throw new Error('Measurement variant is required');
-    }
-    if (!this.position) {
-      throw new Error('Measurement position is required');
-    }
-
-    return new Measurement(
-      this.type,
-      this.variant,
-      this.position,
-      this.windowSize
-    );
-  }
-}
-
-module.exports = MeasurementBuilder;

helper/measurements/MeasurementContainer.js

@@ -1,200 +0,0 @@
-const MeasurementBuilder = require('./MeasurementBuilder');
-
-class MeasurementContainer {
-  constructor(options = {}, logger) {
-    this.logger = logger;
-    this.measurements = {};
-    this.windowSize = options.windowSize || 10; // Default window size
-    
-    // For chaining context
-    this._currentType = null;
-    this._currentVariant = null;
-    this._currentPosition = null;
-  }
-
-  // Chainable methods
-  type(typeName) {
-    this._currentType = typeName;
-    this._currentVariant = null;
-    this._currentPosition = null;
-    return this;
-  }
-
-  variant(variantName) {
-    if (!this._currentType) {
-      throw new Error('Type must be specified before variant');
-    }
-    this._currentVariant = variantName;
-    this._currentPosition = null;
-    return this;
-  }
-
-  position(positionName) {
-    if (!this._currentVariant) {
-      throw new Error('Variant must be specified before position');
-    }
-    this._currentPosition = positionName;
-    return this;
-  }
-
-  // Core methods that complete the chain
-  value(val, timestamp = Date.now()) {
-    if (!this._ensureChainIsValid()) return this;
-    
-    const measurement = this._getOrCreateMeasurement();
-    measurement.setValue(val, timestamp);
-    return this;
-  }
-
-  unit(unitName) {
-    if (!this._ensureChainIsValid()) return this;
-    
-    const measurement = this._getOrCreateMeasurement();
-    measurement.setUnit(unitName);
-    return this;
-  }
-
-  // Terminal operations - get data out
-  get() {
-    if (!this._ensureChainIsValid()) return null;
-    return this._getOrCreateMeasurement();
-  }
-
-  getCurrentValue() {
-    const measurement = this.get();
-    return measurement ? measurement.getCurrentValue() : null;
-  }
-
-  getAverage() {
-    const measurement = this.get();
-    return measurement ? measurement.getAverage() : null;
-  }
-
-  getMin() {
-    const measurement = this.get();
-    return measurement ? measurement.getMin() : null;
-  }
-
-  getMax() {
-    const measurement = this.get();
-    return measurement ? measurement.getMax() : null;
-  }
-
-  getAllValues() {
-    const measurement = this.get();
-    return measurement ? measurement.getAllValues() : null;
-  }
-
-  // Difference calculations between positions
-  difference() {
-    if (!this._currentType || !this._currentVariant) {
-      throw new Error('Type and variant must be specified for difference calculation');
-    }
-    
-    // Save position to restore chain state after operation
-    const savedPosition = this._currentPosition;
-    
-    // Get upstream measurement
-    this._currentPosition = 'upstream';
-    const upstream = this.get();
-    
-    // Get downstream measurement
-    this._currentPosition = 'downstream';
-    const downstream = this.get();
-    
-    // Restore chain state
-    this._currentPosition = savedPosition;
-    
-    if (!upstream || !downstream || upstream.values.length === 0 || downstream.values.length === 0) {
-      return null;
-    }
-    
-    // Ensure units match
-    let downstreamForCalc = downstream;
-    if (upstream.unit && downstream.unit && upstream.unit !== downstream.unit) {
-      try {
-        downstreamForCalc = downstream.convertTo(upstream.unit);
-      } catch (error) {
-        if (this.logger) {
-          this.logger.error(`Unit conversion failed: ${error.message}`);
-        }
-        return null;
-      }
-    }
-
-    return {
-      value: downstreamForCalc.getCurrentValue() - upstream.getCurrentValue() ,
-      avgDiff: downstreamForCalc.getAverage() - upstream.getAverage() ,
-      unit: upstream.unit
-    };
-  }
-
-  // Helper methods
-  _ensureChainIsValid() {
-    if (!this._currentType || !this._currentVariant || !this._currentPosition) {
-      if (this.logger) {
-        this.logger.error('Incomplete measurement chain, required: type, variant, and position');
-      }
-      return false;
-    }
-    return true;
-  }
-
-  _getOrCreateMeasurement() {
-    // Initialize nested structure if needed
-    if (!this.measurements[this._currentType]) {
-      this.measurements[this._currentType] = {};
-    }
-    
-    if (!this.measurements[this._currentType][this._currentVariant]) {
-      this.measurements[this._currentType][this._currentVariant] = {};
-    }
-    
-    if (!this.measurements[this._currentType][this._currentVariant][this._currentPosition]) {
-      this.measurements[this._currentType][this._currentVariant][this._currentPosition] = 
-        new MeasurementBuilder()
-          .setType(this._currentType)
-          .setVariant(this._currentVariant)
-          .setPosition(this._currentPosition)
-          .setWindowSize(this.windowSize)
-          .build();
-    }
-    
-    return this.measurements[this._currentType][this._currentVariant][this._currentPosition];
-  }
-
-  // Additional utility methods
-  getTypes() {
-    return Object.keys(this.measurements);
-  }
-
-  getVariants() {
-    if (!this._currentType) {
-      throw new Error('Type must be specified before listing variants');
-    }
-    return this.measurements[this._currentType] ? 
-      Object.keys(this.measurements[this._currentType]) : [];
-  }
-
-  getPositions() {
-    if (!this._currentType || !this._currentVariant) {
-      throw new Error('Type and variant must be specified before listing positions');
-    }
-    
-    if (!this.measurements[this._currentType] || 
-        !this.measurements[this._currentType][this._currentVariant]) {
-      return [];
-    }
-    
-    return Object.keys(this.measurements[this._currentType][this._currentVariant]);
-  }
-
-  clear() {
-    this.measurements = {};
-    this._currentType = null;
-    this._currentVariant = null;
-    this._currentPosition = null;
-  }
-}
-
-module.exports = MeasurementContainer;

helper/measurements/README.md

@@ -1,89 +0,0 @@
-# Measurement System Documentation
-
-This system provides a flexible way to store, retrieve, and analyze measurement data using a chainable API.
-
-## Basic Usage
-
-```javascript
-const { MeasurementContainer } = require('./index');
-const container = new MeasurementContainer({ windowSize: 20 });
-
-// Set values
-container.type('pressure').variant('measured').position('upstream').value(100).unit('psi');
-
-// Get values
-const upstreamPressure = container.type('pressure').variant('measured').position('upstream').getCurrentValue();
-console.log(`Upstream pressure: ${upstreamPressure}`);
-```
-
-## Chainable API Methods
-
-### Setting Context
-- `type(typeName)` - Set the measurement type (pressure, flow, etc.)
-- `variant(variantName)` - Set the variant (measured, predicted, etc.)
-- `position(positionName)` - Set the position (upstream, downstream, etc.)
-
-### Setting Data
-- `value(val, [timestamp])` - Add a value with optional timestamp
-- `unit(unitName)` - Set the measurement unit
-
-### Getting Data
-- `get()` - Get the measurement object
-- `getCurrentValue()` - Get the most recent value
-- `getAverage()` - Calculate average of all values
-- `getMin()` - Get minimum value
-- `getMax()` - Get maximum value
-
-### Calculations
-- `difference()` - Calculate difference between upstream and downstream positions
-
-### Listing Available Data
-- `getTypes()` - Get all measurement types 
-- `listVariants()` - List variants for current type
-- `listPositions()` - List positions for current type and variant
-
-## Example Workflows
-
-### Setting and retrieving values
-```javascript
-// Set a measurement
-container.type('flow')
-         .variant('measured')
-         .position('upstream')
-         .value(120)
-         .unit('gpm');
-
-// Retrieve the same measurement
-const flow = container.type('flow')
-                     .variant('measured')
-                     .position('upstream')
-                     .getCurrentValue();
-```
-
-### Calculating differences
-```javascript
-// Set upstream and downstream measurements
-container.type('pressure').variant('measured').position('upstream').value(100).unit('psi');
-container.type('pressure').variant('measured').position('downstream').value(95).unit('psi');
-
-// Calculate the difference
-const diff = container.type('pressure').variant('measured').difference();
-console.log(`Pressure drop: ${diff.currentDiff} ${diff.unit}`);
-```
-
-### Working with historical data
-```javascript
-// Add multiple values
-container.type('temperature')
-         .variant('measured')
-         .position('outlet')
-         .value(72)
-         .value(74)
-         .value(73)
-         .unit('F');
-
-// Get statistics
-const avg = container.type('temperature').variant('measured').position('outlet').getAverage();
-const min = container.type('temperature').variant('measured').position('outlet').getMin();
-const max = container.type('temperature').variant('measured').position('outlet').getMax();
-```

helper/measurements/examples.js

@@ -1,58 +0,0 @@
-const { MeasurementContainer } = require('./index');
-
-// Create a container
-const container = new MeasurementContainer({ windowSize: 20 });
-
-// Example 1: Setting values with chaining
-console.log('--- Example 1: Setting values ---');
-container.type('pressure').variant('measured').position('upstream').value(100).unit('psi');
-container.type('pressure').variant('measured').position('downstream').value(95).unit('psi');
-container.type('pressure').variant('measured').position('downstream').value(80);
-
-// Example 2: Getting values with chaining
-console.log('--- Example 2: Getting values ---');
-const upstreamValue = container.type('pressure').variant('measured').position('upstream').getCurrentValue();
-const upstreamUnit = container.type('pressure').variant('measured').position('upstream').get().unit;
-console.log(`Upstream pressure: ${upstreamValue} ${upstreamUnit}`);
-const downstreamValue = container.type('pressure').variant('measured').position('downstream').getCurrentValue();
-const downstreamUnit = container.type('pressure').variant('measured').position('downstream').get().unit;
-console.log(`Downstream pressure: ${downstreamValue} ${downstreamUnit}`);
-
-// Example 3: Calculations using chained methods
-console.log('--- Example 3: Calculations ---');
-container.type('flow').variant('predicted').position('upstream').value(200).unit('gpm');
-container.type('flow').variant('predicted').position('downstream').value(195).unit('gpm');
-
-const flowAvg = container.type('flow').variant('predicted').position('upstream').getAverage();
-console.log(`Average upstream flow: ${flowAvg} gpm`);
-
-// Example 4: Getting pressure difference
-console.log('--- Example 4: Difference calculations ---');
-const pressureDiff = container.type('pressure').variant('measured').difference();
-console.log(`Pressure difference: ${pressureDiff.value} ${pressureDiff.unit}`);
-
-// Example 5: Adding multiple values to track history
-console.log('--- Example 5: Multiple values ---');
-// Add several values to upstream flow
-container.type('flow').variant('measured').position('upstream')
-  .value(210).value(215).value(205).unit('gpm');
-
-// Then get statistics
-console.log('Flow statistics:');
-console.log(`- Current: ${container.type('flow').variant('measured').position('upstream').getCurrentValue()} gpm`);
-console.log(`- Average: ${container.type('flow').variant('measured').position('upstream').getAverage()} gpm`);
-console.log(`- Min: ${container.type('flow').variant('measured').position('upstream').getMin()} gpm`);
-console.log(`- Max: ${container.type('flow').variant('measured').position('upstream').getMax()} gpm`);
-console.log(`Show all values : ${JSON.stringify(container.type('flow').variant('measured').position('upstream').getAllValues())}`);
-
-// Example 6: Listing available data
-console.log('--- Example 6: Listing available data ---');
-console.log('Types:', container.getTypes());
-console.log('Pressure variants:', container.type('pressure').getVariants());
-console.log('Measured pressure positions:', container.type('pressure').variant('measured').getPositions());
-
-module.exports = {
-  runExamples: () => {
-    console.log('Examples of the measurement chainable API');
-  }
-};

helper/measurements/index.js

@@ -1,9 +0,0 @@
-const MeasurementContainer = require('./MeasurementContainer');
-const Measurement = require('./Measurement');
-const MeasurementBuilder = require('./MeasurementBuilder');
-
-module.exports = {
-  MeasurementContainer,
-  Measurement,
-  MeasurementBuilder
-};

helper/nodeTemplates.js

@@ -1,56 +0,0 @@
-const nodeTemplates = {
-  asset: {
-    category: "digital asset",
-    color: "#4f8582",
-    defaults: {
-      name: { value: "", required: true },
-      enableLog: { value: false },
-      logLevel: { value: "error" },
-      parent: { value: "downstream" }, // indicates the position vs the parent in the process downstream,upstream or none.
-      supplier: { value: "" },
-      subType: { value: "" },
-      model: { value: "" },
-      unit: { value: "" },
-    },
-    inputs: 1,
-    outputs: 3,
-    inputLabels: ["Machine Input"],
-    outputLabels: ["process", "dbase", "parent"],
-    icon: "font-awesome/fa-cogs",
-    elements: {
-      // Basic fields
-      name: "node-input-name",
-      // Logging fields
-      logCheckbox: "node-input-enableLog",
-      logLevelSelect: "node-input-logLevel",
-      rowLogLevel: "row-logLevel",
-      // Asset fields
-      supplier: "node-input-supplier",
-      subType: "node-input-subType",
-      model: "node-input-model",
-      unit: "node-input-unit",
-      //position vs parent
-      parent: "node-input-parent",
-    },
-    projectSettingsURL:
-      "http://localhost:1880/generalFunctions/settings/projectSettings.json",
-  },
-
-  exampleTemplate: {
-    category: "digital twin",
-    color: "#004080",
-    defaults: {
-      name: { value: "", required: true },
-      foo: { value: 42 },
-    },
-    inputs: 2,
-    outputs: 2,
-    inputLabels: ["In A", "In B"],
-    outputLabels: ["Out A", "Out B"],
-    icon: "font-awesome/fa-gears",
-  },
-
-  // …add more node “templates” here…
-};
-
-export default nodeTemplates;

helper/nrmse/errorMetric.test.js

@@ -1,297 +0,0 @@
-const ErrorMetrics = require('./errorMetrics');
-
-// Dummy logger for tests
-const logger = {
-    error: console.error,
-    debug: console.log,
-    info: console.log
-};
-
-const config = {
-    thresholds: {
-        NRMSE_LOW: 0.05,
-        NRMSE_MEDIUM: 0.10,
-        NRMSE_HIGH: 0.15,
-        LONG_TERM_LOW: 0.02,
-        LONG_TERM_MEDIUM: 0.04,
-        LONG_TERM_HIGH: 0.06
-    }
-};
-
-class ErrorMetricsTester {
-    constructor() {
-        this.totalTests = 0;
-        this.passedTests = 0;
-        this.failedTests = 0;
-        this.errorMetrics = new ErrorMetrics(config, logger);
-    }
-
-    assert(condition, message) {
-        this.totalTests++;
-        if (condition) {
-            console.log(`✓ PASS: ${message}`);
-            this.passedTests++;
-        } else {
-            console.log(`✗ FAIL: ${message}`);
-            this.failedTests++;
-        }
-    }
-
-    testMeanSquaredError() {
-        console.log("\nTesting Mean Squared Error...");
-        const predicted = [1, 2, 3];
-        const measured = [1, 3, 5];
-        const mse = this.errorMetrics.meanSquaredError(predicted, measured);
-        this.assert(Math.abs(mse - 1.67) < 0.1, "MSE correctly calculated");
-    }
-
-    testRootMeanSquaredError() {
-        console.log("\nTesting Root Mean Squared Error...");
-        const predicted = [1, 2, 3];
-        const measured = [1, 3, 5];
-        const rmse = this.errorMetrics.rootMeanSquaredError(predicted, measured);
-        this.assert(Math.abs(rmse - 1.29) < 0.1, "RMSE correctly calculated");
-    }
-
-    testNormalizedRMSE() {
-        console.log("\nTesting Normalized RMSE...");
-        const predicted = [100, 102, 104];
-        const measured = [98, 103, 107];
-        const processMin = 90, processMax = 110;
-        const nrmse = this.errorMetrics.normalizedRootMeanSquaredError(predicted, measured, processMin, processMax);
-        this.assert(typeof nrmse === 'number' && nrmse > 0, "Normalized RMSE calculated correctly");
-    }
-
-    testNormalizeUsingRealtime() {
-        console.log("\nTesting Normalize Using Realtime...");
-        const predicted = [100, 102, 104];
-        const measured = [98, 103, 107];
-        
-        try {
-            const nrmse = this.errorMetrics.normalizeUsingRealtime(predicted, measured);
-            this.assert(typeof nrmse === 'number' && nrmse > 0, "Normalize using realtime calculated correctly");
-        } catch (error) {
-            this.assert(false, `Normalize using realtime failed: ${error.message}`);
-        }
-        
-        // Test with identical values to check error handling
-        const sameValues = [100, 100, 100];
-        try {
-            this.errorMetrics.normalizeUsingRealtime(sameValues, sameValues);
-            this.assert(false, "Should throw error with identical values");
-        } catch (error) {
-            this.assert(true, "Correctly throws error when min/max are the same");
-        }
-    }
-
-    testLongTermNRMSD() {
-        console.log("\nTesting Long Term NRMSD Accumulation...");
-        // Reset the accumulation values
-        this.errorMetrics.cumNRMSD = 0;
-        this.errorMetrics.cumCount = 0;
-        
-        let lastValue = 0;
-        for (let i = 0; i < 100; i++) {
-            lastValue = this.errorMetrics.longTermNRMSD(0.1 + i * 0.001);
-        }
-        
-        this.assert(
-            this.errorMetrics.cumCount === 100 && 
-            this.errorMetrics.cumNRMSD !== 0 &&
-            lastValue !== 0, 
-            "Long term NRMSD accumulates over 100 iterations"
-        );
-        
-        // Test that values are returned only after accumulating 100 samples
-        this.errorMetrics.cumNRMSD = 0;
-        this.errorMetrics.cumCount = 0;
-        
-        for (let i = 0; i < 99; i++) {
-            const result = this.errorMetrics.longTermNRMSD(0.1);
-            this.assert(result === 0, "No longTermNRMSD returned before 100 samples");
-        }
-        
-        // Use a different value for the 100th sample to ensure a non-zero result
-        const result = this.errorMetrics.longTermNRMSD(0.2);
-        this.assert(result !== 0, "longTermNRMSD returned after 100 samples");
-    }
-
-    testDetectImmediateDrift() {
-        console.log("\nTesting Immediate Drift Detection...");
-        
-        // Test high drift
-        let drift = this.errorMetrics.detectImmediateDrift(config.thresholds.NRMSE_HIGH + 0.01);
-        this.assert(drift.level === 3, "Detects high immediate drift correctly");
-        
-        // Test medium drift
-        drift = this.errorMetrics.detectImmediateDrift(config.thresholds.NRMSE_MEDIUM + 0.01);
-        this.assert(drift.level === 2, "Detects medium immediate drift correctly");
-        
-        // Test low drift
-        drift = this.errorMetrics.detectImmediateDrift(config.thresholds.NRMSE_LOW + 0.01);
-        this.assert(drift.level === 1, "Detects low immediate drift correctly");
-        
-        // Test no drift
-        drift = this.errorMetrics.detectImmediateDrift(config.thresholds.NRMSE_LOW - 0.01);
-        this.assert(drift.level === 0, "Detects no immediate drift correctly");
-    }
-
-    testDetectLongTermDrift() {
-        console.log("\nTesting Long Term Drift Detection...");
-        
-        // Test high drift
-        let drift = this.errorMetrics.detectLongTermDrift(config.thresholds.LONG_TERM_HIGH + 0.01);
-        this.assert(drift.level === 3, "Detects high long-term drift correctly");
-        
-        // Test medium drift
-        drift = this.errorMetrics.detectLongTermDrift(config.thresholds.LONG_TERM_MEDIUM + 0.01);
-        this.assert(drift.level === 2, "Detects medium long-term drift correctly");
-        
-        // Test low drift
-        drift = this.errorMetrics.detectLongTermDrift(config.thresholds.LONG_TERM_LOW + 0.01);
-        this.assert(drift.level === 1, "Detects low long-term drift correctly");
-        
-        // Test no drift
-        drift = this.errorMetrics.detectLongTermDrift(config.thresholds.LONG_TERM_LOW - 0.01);
-        this.assert(drift.level === 0, "Detects no long-term drift correctly");
-        
-        // Test negative drift values
-        drift = this.errorMetrics.detectLongTermDrift(-config.thresholds.LONG_TERM_HIGH - 0.01);
-        this.assert(drift.level === 3, "Detects negative high long-term drift correctly");
-    }
-
-    testDriftDetection() {
-        console.log("\nTesting Combined Drift Detection...");
-        
-        let nrmseHigh = config.thresholds.NRMSE_HIGH + 0.01;
-        let ltNRMSD = 0;
-        
-        let result = this.errorMetrics.detectDrift(nrmseHigh, ltNRMSD);
-        
-        this.assert(
-            result !== null && 
-            result.ImmDrift && 
-            result.ImmDrift.level === 3 &&
-            result.LongTermDrift.level === 0, 
-            "Detects high immediate drift with no long-term drift"
-        );
-
-        nrmseHigh = config.thresholds.NRMSE_LOW - 0.01;
-        ltNRMSD = config.thresholds.LONG_TERM_MEDIUM + 0.01;
-        result = this.errorMetrics.detectDrift(nrmseHigh, ltNRMSD);
-        this.assert(
-            result !== null && 
-            result.ImmDrift.level === 0 &&
-            result.LongTermDrift && 
-            result.LongTermDrift.level === 2, 
-            "Detects medium long-term drift with no immediate drift"
-        );
-
-        nrmseHigh = config.thresholds.NRMSE_MEDIUM + 0.01;
-        ltNRMSD = config.thresholds.LONG_TERM_MEDIUM + 0.01;
-        result = this.errorMetrics.detectDrift(nrmseHigh, ltNRMSD);
-        this.assert(
-            result.ImmDrift.level === 2 && 
-            result.LongTermDrift.level === 2, 
-            "Detects both medium immediate and medium long-term drift"
-        );
-
-        nrmseHigh = config.thresholds.NRMSE_LOW - 0.01;
-        ltNRMSD = config.thresholds.LONG_TERM_LOW - 0.01;
-        result = this.errorMetrics.detectDrift(nrmseHigh, ltNRMSD);
-        this.assert(
-            result.ImmDrift.level === 0 && 
-            result.LongTermDrift.level === 0, 
-            "No significant drift detected when under thresholds"
-        );
-    }
-
-    testAssessDrift() {
-        console.log("\nTesting assessDrift function...");
-        
-        // Reset accumulation for testing
-        this.errorMetrics.cumNRMSD = 0;
-        this.errorMetrics.cumCount = 0;
-        
-        const predicted = [100, 101, 102, 103];
-        const measured = [90, 91, 92, 93]; 
-        const processMin = 90, processMax = 110;
-        
-        let result = this.errorMetrics.assessDrift(predicted, measured, processMin, processMax);
-        
-        this.assert(
-            result !== null && 
-            typeof result.nrmse === 'number' &&
-            typeof result.longTermNRMSD === 'number' &&
-            typeof result.immediateLevel === 'number' &&
-            typeof result.immediateFeedback === 'string' &&
-            typeof result.longTermLevel === 'number' &&
-            typeof result.longTermFeedback === 'string',
-            "assessDrift returns complete result structure"
-        );
-
-        this.assert(
-            result.immediateLevel > 0,
-            "assessDrift detects immediate drift with significant difference"
-        );
-
-        // Test with identical values
-        result = this.errorMetrics.assessDrift(predicted, predicted, processMin, processMax);
-        this.assert(
-            result.nrmse === 0 &&
-            result.immediateLevel === 0, 
-            "assessDrift indicates no immediate drift when predicted equals measured"
-        );
-
-        // Test with slight drift 
-        const measuredSlight = [100, 100.5, 101, 101.5];
-        result = this.errorMetrics.assessDrift(predicted, measuredSlight, processMin, processMax);
-        
-        this.assert(
-            result !== null && 
-            result.nrmse < 0.05 &&
-            (result.immediateLevel < 2),
-            "assessDrift returns appropriate levels for slight drift"
-        );
-
-        // Test long-term drift accumulation
-        for (let i = 0; i < 100; i++) {
-            this.errorMetrics.assessDrift(
-                predicted,
-                measured.map(m => m + (Math.random() * 2 - 1)), // Add small random fluctuation
-                processMin,
-                processMax
-            );
-        }
-        
-        result = this.errorMetrics.assessDrift(predicted, measured, processMin, processMax);
-        this.assert(
-            result.longTermNRMSD !== 0,
-            "Long-term drift accumulates over multiple assessments"
-        );
-    }
-
-    async runAllTests() {
-        console.log("\nStarting Error Metrics Tests...\n");
-        this.testMeanSquaredError();
-        this.testRootMeanSquaredError();
-        this.testNormalizedRMSE();
-        this.testNormalizeUsingRealtime();
-        this.testLongTermNRMSD();
-        this.testDetectImmediateDrift();
-        this.testDetectLongTermDrift();
-        this.testDriftDetection();
-        this.testAssessDrift();
-        
-        console.log("\nTest Summary:");
-        console.log(`Total Tests: ${this.totalTests}`);
-        console.log(`Passed: ${this.passedTests}`);
-        console.log(`Failed: ${this.failedTests}`);
-
-        process.exit(this.failedTests > 0 ? 1 : 0);
-    }
-}
-
-// Run all tests
-const tester = new ErrorMetricsTester();
-tester.runAllTests().catch(console.error);

helper/nrmse/errorMetrics.js

@@ -1,154 +0,0 @@
-//load local dependencies
-const EventEmitter = require('events');
-
-//load all config modules
-const defaultConfig = require('./nrmseConfig.json');
-const ConfigUtils = require('../configUtils');
-
-class ErrorMetrics {
-  constructor(config = {}, logger) {
-
-    this.emitter = new EventEmitter();  // Own EventEmitter
-    this.configUtils = new ConfigUtils(defaultConfig);
-    this.config = this.configUtils.initConfig(config);
-  
-    // Init after config is set
-    this.logger = logger;
-
-    // For long-term NRMSD accumulation
-    this.cumNRMSD = 0;
-    this.cumCount = 0;
-  }
-
-  //INCLUDE timestamps in the next update OLIFANT
-  meanSquaredError(predicted, measured) {
-    if (predicted.length !== measured.length) {
-      this.logger.error("Comparing MSE Arrays must have the same length.");
-      return 0;
-    }
-
-
-    let sumSqError = 0;
-    for (let i = 0; i < predicted.length; i++) {
-      const err = predicted[i] - measured[i];
-      sumSqError += err * err;
-    }
-    return sumSqError / predicted.length;
-  }
-
-  rootMeanSquaredError(predicted, measured) {
-    return Math.sqrt(this.meanSquaredError(predicted, measured));
-  }
-
-  normalizedRootMeanSquaredError(predicted, measured, processMin, processMax) {
-    const range = processMax - processMin;
-    if (range <= 0) {
-      this.logger.error("Invalid process range: processMax must be greater than processMin.");
-    }
-    const rmse = this.rootMeanSquaredError(predicted, measured);
-    return rmse / range;
-  }
-
-  longTermNRMSD(input) {
-
-    const storedNRMSD = this.cumNRMSD;
-    const storedCount = this.cumCount;
-    const newCount = storedCount + 1;
-    
-    // Update cumulative values
-    this.cumCount = newCount;
-    
-    // Calculate new running average
-    if (storedCount === 0) {
-      this.cumNRMSD = input; // First value
-    } else {
-      // Running average formula: newAvg = oldAvg + (newValue - oldAvg) / newCount
-      this.cumNRMSD = storedNRMSD + (input - storedNRMSD) / newCount;
-    }
-
-    if(newCount >= 100) {
-      // Return the current NRMSD value, not just the contribution from this sample
-      return this.cumNRMSD;
-    }
-    return 0;
-  }
-
-  normalizeUsingRealtime(predicted, measured) {
-    const realtimeMin = Math.min(Math.min(...predicted), Math.min(...measured));
-    const realtimeMax = Math.max(Math.max(...predicted), Math.max(...measured));
-    const range = realtimeMax - realtimeMin;
-    if (range <= 0) {
-      throw new Error("Invalid process range: processMax must be greater than processMin.");
-    }
-    const rmse = this.rootMeanSquaredError(predicted, measured);
-    return rmse / range;
-  }
-
-  detectImmediateDrift(nrmse) {
-    let ImmDrift = {};
-    this.logger.debug(`checking immediate drift with thresholds : ${this.config.thresholds.NRMSE_HIGH} ${this.config.thresholds.NRMSE_MEDIUM} ${this.config.thresholds.NRMSE_LOW}`);
-    switch (true) {
-      case( nrmse > this.config.thresholds.NRMSE_HIGH ) :
-        ImmDrift = {level : 3 , feedback : "High immediate drift detected"};
-        break;
-      case( nrmse > this.config.thresholds.NRMSE_MEDIUM ) :
-        ImmDrift = {level : 2 , feedback : "Medium immediate drift detected"};
-        break;
-      case(nrmse > this.config.thresholds.NRMSE_LOW ):
-        ImmDrift = {level : 1 , feedback : "Low immediate drift detected"};
-        break;
-      default:
-        ImmDrift = {level : 0 , feedback : "No drift detected"};
-    }
-    return ImmDrift;
-  }
-
-  detectLongTermDrift(longTermNRMSD) {
-    let LongTermDrift = {};
-    this.logger.debug(`checking longterm drift with thresholds : ${this.config.thresholds.LONG_TERM_HIGH} ${this.config.thresholds.LONG_TERM_MEDIUM} ${this.config.thresholds.LONG_TERM_LOW}`);
-    switch (true) {
-      case(Math.abs(longTermNRMSD) > this.config.thresholds.LONG_TERM_HIGH) :
-        LongTermDrift = {level : 3 , feedback : "High long-term drift detected"};
-        break;
-      case (Math.abs(longTermNRMSD) > this.config.thresholds.LONG_TERM_MEDIUM) :
-        LongTermDrift = {level : 2 , feedback : "Medium long-term drift detected"};
-        break;
-      case ( Math.abs(longTermNRMSD) > this.config.thresholds.LONG_TERM_LOW ) :
-        LongTermDrift = {level : 1 , feedback : "Low long-term drift detected"};
-        break;
-      default:
-        LongTermDrift = {level : 0 , feedback : "No drift detected"}; 
-    }
-    return LongTermDrift;
-  }
-
-  detectDrift(nrmse, longTermNRMSD) {
-    const ImmDrift = this.detectImmediateDrift(nrmse);
-    const LongTermDrift = this.detectLongTermDrift(longTermNRMSD);
-    return { ImmDrift, LongTermDrift };
-  }
-
-  // asses the drift
-  assessDrift(predicted, measured, processMin, processMax) {
-    // Compute NRMSE and check for immediate drift
-    const nrmse = this.normalizedRootMeanSquaredError(predicted, measured, processMin, processMax);
-    this.logger.debug(`NRMSE: ${nrmse}`);
-    // cmopute long-term NRMSD and add result to cumalitve NRMSD
-    const longTermNRMSD = this.longTermNRMSD(nrmse);
-    // return the drift
-    // Return the drift assessment object
-    const driftAssessment = this.detectDrift(nrmse, longTermNRMSD);
-    return {
-      nrmse,
-      longTermNRMSD,
-      immediateLevel: driftAssessment.ImmDrift.level,
-      immediateFeedback: driftAssessment.ImmDrift.feedback,
-      longTermLevel: driftAssessment.LongTermDrift.level,
-      longTermFeedback: driftAssessment.LongTermDrift.feedback
-    };
-  }
-
-
-}
-
-module.exports = ErrorMetrics;

helper/nrmse/nrmseConfig.json

@@ -1,138 +0,0 @@
-{
-  "general": {
-    "name": {
-      "default": "ErrorMetrics",
-      "rules": {
-        "type": "string",
-        "description": "A human-readable name for the configuration."
-      }
-    },
-    "id": {
-      "default": null,
-      "rules": {
-        "type": "string",
-        "nullable": true,
-        "description": "A unique identifier for this configuration, assigned dynamically when needed."
-      }
-    },
-    "unit": {
-      "default": "unitless",
-      "rules": {
-        "type": "string",
-        "description": "The unit used for the state values (e.g., 'meters', 'seconds', 'unitless')."
-      }
-    },
-    "logging": {
-      "logLevel": {
-        "default": "info",
-        "rules": {
-          "type": "enum",
-          "values": [
-            {
-              "value": "debug",
-              "description": "Log messages are printed for debugging purposes."
-            },
-            {
-              "value": "info",
-              "description": "Informational messages are printed."
-            },
-            {
-              "value": "warn",
-              "description": "Warning messages are printed."
-            },
-            {
-              "value": "error",
-              "description": "Error messages are printed."
-            }
-          ]
-        }
-      },
-      "enabled": {
-        "default": true,
-        "rules": {
-          "type": "boolean",
-          "description": "Indicates whether logging is active. If true, log messages will be generated."
-        }
-      }
-    }
-  },
-  "functionality": {
-    "softwareType": {
-      "default": "errorMetrics",
-      "rules": {
-        "type": "string",
-        "description": "Logical name identifying the software type."
-      }
-    },
-    "role": {
-      "default": "error calculation",
-      "rules": {
-        "type": "string",
-        "description": "Functional role within the system."
-      }
-    }
-  },
-  "mode": {
-    "current": {
-      "default": "active",
-      "rules": {
-        "type": "enum",
-        "values": [
-          {
-            "value": "active",
-            "description": "The error metrics calculation is active."
-          },
-          {
-            "value": "inactive",
-            "description": "The error metrics calculation is inactive."
-          }
-        ],
-        "description": "The operational mode of the error metrics calculation."
-      }
-    }
-  },
-  "thresholds": {
-    "NRMSE_LOW": {
-      "default": 0.05,
-      "rules": {
-        "type": "number",
-        "description": "Low threshold for normalized root mean squared error."
-      }
-    },
-    "NRMSE_MEDIUM": {
-      "default": 0.10,
-      "rules": {
-        "type": "number",
-        "description": "Medium threshold for normalized root mean squared error."
-      }
-    },
-    "NRMSE_HIGH": {
-      "default": 0.15,
-      "rules": {
-        "type": "number",
-        "description": "High threshold for normalized root mean squared error."
-      }
-    },
-    "LONG_TERM_LOW": {
-      "default": 0.02,
-      "rules": {
-        "type": "number",
-        "description": "Low threshold for long-term normalized root mean squared deviation."
-      }
-    },
-    "LONG_TERM_MEDIUM": {
-      "default": 0.04,
-      "rules": {
-        "type": "number",
-        "description": "Medium threshold for long-term normalized root mean squared deviation."
-      }
-    },
-    "LONG_TERM_HIGH": {
-      "default": 0.06,
-      "rules": {
-        "type": "number",
-        "description": "High threshold for long-term normalized root mean squared deviation."
-      }
-    }
-  }
-}

helper/outliers/outlierDetection.js

@@ -1,89 +0,0 @@
-class DynamicClusterDeviation {
-    constructor() {
-        this.clusters = []; // Stores clusters as { center, spread, count }
-    }
-
-    update(value) {
-        console.log(`\nProcessing value: ${value}`);
-
-        // If no clusters exist, create the first one
-        if (this.clusters.length === 0) {
-            this.clusters.push({ center: value, spread: 0, count: 1 });
-            console.log(`  → First cluster created at ${value}`);
-            return { value, isOutlier: false };
-        }
-
-        // Step 1: Find the closest cluster
-        let bestMatch = null;
-        let minDistance = Infinity;
-
-        for (const cluster of this.clusters) {
-            const distance = Math.abs(value - cluster.center);
-            console.log(`  Checking against cluster at ${cluster.center} (spread: ${cluster.spread}, count: ${cluster.count}) → distance: ${distance}`);
-
-            if (distance < minDistance) {
-                bestMatch = cluster;
-                minDistance = distance;
-            }
-        }
-
-        console.log(`  Closest cluster found at ${bestMatch.center} with distance: ${minDistance}`);
-
-        // Step 2: Compute dynamic threshold
-        const dynamicThreshold = 1 + 5 / Math.sqrt(bestMatch.count + 1);
-        const allowedDeviation = dynamicThreshold * (bestMatch.spread || 1);
-
-        console.log(`  Dynamic threshold: ${dynamicThreshold.toFixed(2)}, Allowed deviation: ${allowedDeviation.toFixed(2)}`);
-
-        // Step 3: Check if value fits within the dynamically adjusted cluster spread
-        if (minDistance <= allowedDeviation) {
-            // Update cluster dynamically
-            const newCenter = (bestMatch.center * bestMatch.count + value) / (bestMatch.count + 1);
-            const newSpread = Math.max(bestMatch.spread, minDistance);
-            bestMatch.center = newCenter;
-            bestMatch.spread = newSpread;
-            bestMatch.count += 1;
-
-            console.log(`  ✅ Value fits in cluster! Updating cluster:`);
-            console.log(`    → New center: ${newCenter.toFixed(2)}`);
-            console.log(`    → New spread: ${newSpread.toFixed(2)}`);
-            console.log(`    → New count: ${bestMatch.count}`);
-            
-            return { value, isOutlier: false };
-        } else {
-            // If too far, create a new cluster
-            this.clusters.push({ center: value, spread: 0, count: 1 });
-
-            console.log(`  ❌ Outlier detected! New cluster created at ${value}`);
-
-            return { value, isOutlier: true };
-        }
-    }
-}
-
-// Rolling window simulation with outlier detection
-/*
-const detector = new DynamicClusterDeviation();
-const dataStream = [10, 10.2, 10.5, 9.8, 11, 50, 10.3, 200, 201, 200.1, 205, 202, 250, 260, 270, 280, 290, 300];
-
-// Define the number of elements per rolling window chunk.
-const windowSize = 5;
-let rollingWindow = [];
-
-dataStream.forEach((value, index) => {
-    console.log(`\n=== Processing value ${index + 1} ===`);
-    rollingWindow.push(value);
-    const result = detector.update(value);
-    console.log(`Current rolling window: [${rollingWindow.join(', ')}]`);
-    console.log(`Result: value=${result.value} (${result.isOutlier ? 'Outlier' : 'Inlier'})`);
-    
-    // Once the window size is reached, show current cluster states and reset the window for the next chunk.
-    if (rollingWindow.length === windowSize) {
-        console.log("\n--- Rolling window chunk finished ---");
-        console.log("Detector cluster states:", JSON.stringify(detector.clusters, null, 2));
-        rollingWindow = [];
-    }
-});
-
-console.log("\nFinal detector cluster states:", JSON.stringify(detector.clusters, null, 2));
-*/

helper/outputUtils.js

@@ -1,132 +0,0 @@
-//this class will handle the output events for the node red node
-class OutputUtils {
-  constructor() {
-    this.output ={};
-    this.output['influxdb'] = {};
-    this.output['process'] = {};
-  }
-
-  checkForChanges(output, format) {
-    const changedFields = {};
-    for (const key in output) {
-      if (output.hasOwnProperty(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)) {
-          changedFields[key] = JSON.stringify(value);
-        } else {
-          changedFields[key] = value;
-        }
-      }
-    }
-
-    // Update the saved output state.
-    this.output[format] = { ...this.output[format], ...changedFields };
-
-    return changedFields;
-  }
-
-  formatMsg(output, config, format) {
-  
-    //define emtpy message
-      let msg = {};
-
-      // Compare output with last output and only include changed values
-      const changedFields = this.checkForChanges(output,format);
-
-      if (Object.keys(changedFields).length > 0) {
-
-        switch (format) {
-          case 'influxdb':  
-            // Extract the relevant config properties.
-            const relevantConfig = this.extractRelevantConfig(config);
-            // Flatten the tags so that no nested objects are passed on.
-            const flatTags = this.flattenTags(relevantConfig);
-            msg = this.influxDBFormat(changedFields, config, flatTags);
-            
-            break;
-
-          case 'process':
-
-            // Compare output with last output and only include changed values
-            msg = this.processFormat(changedFields,config);
-            //console.log(msg);
-            break;
-
-          default:
-            console.log('Unknown format in output utils');
-            break;
-        }
-        return msg;
-      }
-  }
-  
-
-  influxDBFormat(changedFields, config , flatTags) {
-    // Create the measurement and topic using softwareType and name config.functionality.softwareType + .
-    const measurement = config.general.name;
-    const payload = {
-      measurement: measurement,
-      fields: changedFields,
-      tags: flatTags,
-      timestamp: new Date(),
-    };
-
-    const topic = measurement;
-    const msg = { topic: topic, payload: payload };
-    return msg;
-  }
-
-  flattenTags(obj) {
-    const result = {};
-    for (const key in obj) {
-      if (obj.hasOwnProperty(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)) {
-              result[`${key}_${childKey}`] = String(flatChild[childKey]);
-            }
-          }
-        } else {
-          // InfluxDB tags must be strings.
-          result[key] = String(value);
-        }
-      }
-    }
-    return result;
-  }
-
-  extractRelevantConfig(config) {
-    
-    return {
-      // general properties
-      id: config.general?.id,
-      name: config.general?.name,
-      unit: config.general?.unit,
-      // functionality properties
-      softwareType: config.functionality?.softwareType,
-      role: config.functionality?.role,
-      // asset properties (exclude machineCurve)
-      uuid: config.asset?.uuid,
-      geoLocation: config.asset?.geoLocation,
-      supplier: config.asset?.supplier,
-      type: config.asset?.type,
-      subType: config.asset?.subType,
-      model: config.asset?.model,
-    };
-  }
-
-  processFormat(changedFields,config) {
-        // Create the measurement and topic using softwareType and name config.functionality.softwareType + .
-        const measurement = config.general.name;
-        const payload = changedFields;
-        const topic = measurement;
-        const msg = { topic: topic, payload: payload };
-        return msg;
-  }
-}
-
-module.exports = OutputUtils;

helper/state/movementManager.js

@@ -1,277 +0,0 @@
-//const EventEmitter = require('events');
-
-class movementManager {
-  constructor(config, logger, emitter) {
-    this.emitter = emitter; //new EventEmitter();  //state class emitter
-
-    const { min, max, initial } = config.position;
-    const { speed, maxSpeed, interval } = config.movement;
-
-    this.minPosition = min;
-    this.maxPosition = max;
-    this.currentPosition = initial;
-
-    this.speed = speed;
-    this.maxSpeed = maxSpeed;
-    this.interval = interval;
-    this.timeleft = 0; // timeleft of current movement
-
-    this.logger = logger;
-    this.movementMode = config.movement.mode;
-  }
-
-  getCurrentPosition() {
-    return this.currentPosition;
-  }
-
-  async moveTo(targetPosition, signal) {
-    // Constrain target position if necessary
-    if (
-      targetPosition < this.minPosition ||
-      targetPosition > this.maxPosition
-    ) {
-      targetPosition = this.constrain(targetPosition);
-      this.logger.warn(
-        `New target position=${targetPosition} is constrained to fit between min=${this.minPosition} and max=${this.maxPosition}`
-      );
-    }
-
-    this.logger.info(
-      `Starting movement to position ${targetPosition} in ${this.movementMode} with avg speed=${this.speed}%/s.`
-    );
-
-    if (signal && signal.aborted) {
-      this.logger.debug("Movement aborted.");
-      return;
-    }
-
-    try {
-      // Execute the movement logic based on the mode
-      switch (this.movementMode) {
-        case "staticspeed":
-          const movelinFeedback = await this.moveLinear(targetPosition,signal);
-          this.logger.info(`Linear move: ${movelinFeedback} `);
-          break;
-
-        case "dynspeed":
-          const moveDynFeedback = await this.moveEaseInOut(targetPosition,signal);
-          this.logger.info(`Dynamic move : ${moveDynFeedback}`);
-          break;
-
-        default:
-          throw new Error(`Unsupported movement mode: ${this.movementMode}`);
-      }
-    } catch (error) {
-      this.logger.error(error);
-    }
-  }
-
-  moveLinear(targetPosition, signal) {
-  return new Promise((resolve, reject) => {
-    // Immediate abort if already signalled
-    if (signal?.aborted) {
-      return reject(new Error("Movement aborted"));
-    }
-
-    // Clamp the final target into [minPosition, maxPosition]
-    targetPosition = this.constrain(targetPosition);
-
-    // Compute direction and remaining distance
-    const direction = targetPosition > this.currentPosition ? 1 : -1;
-    const distance  = Math.abs(targetPosition - this.currentPosition);
-
-    // Speed is a fraction [0,1] of full-range per second
-    this.speed = Math.min(Math.max(this.speed, 0), 1);
-    const fullRange = this.maxPosition - this.minPosition;
-    const velocity  = this.speed * fullRange;      // units per second
-    if (velocity === 0) {
-      return reject(new Error("Movement aborted: zero speed"));
-    }
-
-    // Duration and bookkeeping
-    const duration   = distance / velocity;        // seconds to go the remaining distance
-    this.timeleft    = duration;
-    this.logger.debug(
-      `Linear move: dir=${direction}, dist=${distance}, vel=${velocity.toFixed(2)} u/s, dur=${duration.toFixed(2)}s`
-    );
-
-    // Compute how much to move each tick
-    const intervalMs   = this.interval;
-    const intervalSec  = intervalMs / 1000;
-    const stepSize     = direction * velocity * intervalSec;
-
-    const startTime = Date.now();
-
-    // Kick off the loop
-    const intervalId = setInterval(() => {
-      // 7a) Abort check
-      if (signal?.aborted) {
-        clearInterval(intervalId);
-        return reject(new Error("Movement aborted"));
-      }
-
-      //  Advance position and clamp
-      this.currentPosition += stepSize;
-      this.currentPosition = this.constrain(this.currentPosition);
-      this.emitPos(this.currentPosition);
-
-      // Update timeleft
-      const elapsed = (Date.now() - startTime) / 1000;
-      this.timeleft  = Math.max(0, duration - elapsed);
-
-      this.logger.debug(
-        `pos=${this.currentPosition.toFixed(2)}, timeleft=${this.timeleft.toFixed(2)}`
-      );
-
-      // Completed the move?
-      if (
-        (direction > 0 && this.currentPosition >= targetPosition) ||
-        (direction < 0 && this.currentPosition <= targetPosition)
-      ) {
-        clearInterval(intervalId);
-        this.currentPosition = targetPosition;
-        this.emitPos(this.currentPosition);
-        return resolve("Reached target move.");
-      }
-    }, intervalMs);
-
-    // 8) Also catch aborts that happen before the first tick
-    signal?.addEventListener("abort", () => {
-      clearInterval(intervalId);
-      reject(new Error("Movement aborted"));
-    });
-  });
-}
-
-  moveLinearinTime(targetPosition,signal) {
-    return new Promise((resolve, reject) => {
-      // Abort immediately if already signalled
-      if (signal?.aborted) {
-        return reject(new Error("Movement aborted"));
-      }
-      
-      const direction = targetPosition > this.currentPosition ? 1 : -1;
-      const distance = Math.abs(targetPosition - this.currentPosition);
-
-      // Ensure speed is a percentage [0, 1]
-      this.speed = Math.min(Math.max(this.speed, 0), 1);
-
-      // Calculate duration based on percentage of distance per second
-      const duration = 1 / this.speed; // 1 second for 100% of the distance
-
-      this.timeleft = duration; //set this so other classes can use it
-      this.logger.debug(
-        `Linear movement: Direction=${direction}, Distance=${distance}, Duration=${duration}s`
-      );
-
-      let elapsedTime = 0;
-      const interval = this.interval; // Update every x ms
-      const totalSteps = Math.ceil((duration * 1000) / interval);
-      const stepSize = direction * (distance / totalSteps);
-
-      // 2) Set up the abort listener once
-      const intervalId = setInterval(() => {
-        // 3) Check for abort on each tick
-        if (signal?.aborted) {
-          clearInterval(intervalId);
-          return reject(new Error("Movement aborted"));
-        }
-        // Update elapsed time
-        elapsedTime += interval / 1000;
-
-        this.timeleft = duration - elapsedTime; //set this so other classes can use it
-
-        // Update the position incrementally
-        this.currentPosition += stepSize;
-        this.emitPos(this.currentPosition);
-        this.logger.debug(
-          `Using ${this.movementMode} => Current position ${this.currentPosition}`
-        );
-
-        // Check if the target position has been reached
-        if (
-          (direction > 0 && this.currentPosition >= targetPosition) ||
-          (direction < 0 && this.currentPosition <= targetPosition)
-        ) {
-          clearInterval(intervalId);
-          this.currentPosition = targetPosition;
-          resolve(`Reached target move.`);
-        }
-      }, interval);
-      // Also attach abort outside the interval in case it fires before the first tick:
-      signal?.addEventListener("abort", () => {
-        clearInterval(intervalId);
-        reject(new Error("Movement aborted"));
-      });
-    });
-  }
-
-  moveEaseInOut(targetPosition, signal) {
-    return new Promise((resolve, reject) => {
-      // 1) Bail immediately if already aborted
-      if (signal?.aborted) {
-        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);
-
-      const easeFunction = (t) =>
-        t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
-
-      let elapsedTime = 0;
-      const duration = totalDistance / this.speed;
-      this.timeleft = duration;
-      const interval = this.interval;
-
-      // 2) Start the moving loop
-      const intervalId = setInterval(() => {
-        // 3) Check for abort on each tick
-        if (signal?.aborted) {
-          clearInterval(intervalId);
-          return reject(new Error("Movement aborted"));
-        }
-
-        elapsedTime += interval / 1000;
-        const progress = Math.min(elapsedTime / duration, 1);
-        this.timeleft = duration - elapsedTime;
-        const easedProgress = easeFunction(progress);
-        const newPosition =
-          startPosition + (targetPosition - startPosition) * easedProgress;
-
-        this.emitPos(newPosition);
-        this.logger.debug(
-          `Using ${this.movementMode} => Progress=${progress.toFixed(
-            2
-          )}, Eased=${easedProgress.toFixed(2)}`
-        );
-
-        if (progress >= 1) {
-          clearInterval(intervalId);
-          this.currentPosition = targetPosition;
-          resolve(`Reached target move.`);
-        } else {
-          this.currentPosition = newPosition;
-        }
-      }, interval);
-
-      // 4) Also listen once for abort before first tick
-      signal?.addEventListener("abort", () => {
-        clearInterval(intervalId);
-        reject(new Error("Movement aborted"));
-      });
-    });
-  }
-
-  emitPos(newPosition) {
-    this.emitter.emit("positionChange", newPosition);
-  }
-
-  constrain(value) {
-    return Math.min(Math.max(value, this.minPosition), this.maxPosition);
-  }
-}
-
-module.exports = movementManager;

helper/state/state.js

@@ -1,131 +0,0 @@
-//load local dependencies
-const EventEmitter = require('events');
-const StateManager = require('./stateManager');
-const MovementManager = require('./movementManager');
-
-//load all config modules
-const defaultConfig = require('./stateConfig.json');
-const ConfigUtils = require('../../../generalFunctions/helper/configUtils');
-
-class state{
-  constructor(config = {}, logger) {
-
-    this.emitter = new EventEmitter();  // Own EventEmitter
-    this.configUtils = new ConfigUtils(defaultConfig);
-    this.config = this.configUtils.initConfig(config);
-    this.abortController = null;  // new abort controller for aborting async tasks
-    // Init after config is set
-    this.logger = logger;
-
-    // Initialize StateManager for state handling
-    this.stateManager = new StateManager(this.config,this.logger);
-    this.movementManager = new MovementManager(this.config, this.logger, this.emitter);
-
-    this.delayedMove = null;
-    this.mode = this.config.mode.current;
-
-    // Log initialization
-    this.logger.info("State class initialized.");
-
-  }
-
-  // -------- Delegate State Management -------- //
-
-  getMoveTimeLeft() {
-    return this.movementManager.timeleft;
-  }
-  
-  getCurrentState() {
-    return this.stateManager.currentState;
-  }
-
-  getStateDescription() {
-    return this.stateManager.getStateDescription();
-  }
-
-  // -------- Movement Methods -------- //
-  getCurrentPosition() {
-    return this.movementManager.getCurrentPosition();
-  }
-
-  getRunTimeHours() {
-    return this.stateManager.getRunTimeHours();
-  }
-
-  async moveTo(targetPosition) {
-
-    // Check for invalid conditions and throw errors
-    if (targetPosition === this.getCurrentPosition()) {
-      this.logger.warn(`Target position=${targetPosition} is the same as the current position ${this.getCurrentPosition()}. Not executing move.`);
-      return;
-    }
-
-    if (this.stateManager.getCurrentState() !== "operational") {
-      if (this.config.mode.current === "auto") {
-        this.delayedMove = targetPosition;
-        this.logger.warn(`Saving setpoint=${targetPosition} to execute once back in 'operational' state.`);
-      }
-      else{
-        this.logger.warn(`Not able to accept setpoint=${targetPosition} while not in ${this.stateManager.getCurrentState()} state`);
-      }
-      //return early
-      return;
-    }
-    this.abortController = new AbortController();
-    const { signal } = this.abortController;
-    try {
-      const newState = targetPosition < this.getCurrentPosition() ? "decelerating" : "accelerating";
-      await this.transitionToState(newState,signal);  // awaits transition
-      await this.movementManager.moveTo(targetPosition,signal);  // awaits moving
-      this.emitter.emit("movementComplete", { position: targetPosition });
-      await this.transitionToState("operational");
-    } catch (error) {
-      this.logger.error(error);
-    }
-  }
-  
-  // -------- State Transition Methods -------- //
-
-  async transitionToState(targetState, signal) {
-
-    const fromState = this.getCurrentState();
-    const position = this.getCurrentPosition();
-
-    try {
-      
-      this.logger.debug(`Starting transition from ${fromState} to ${targetState}.`);
-      const feedback = await this.stateManager.transitionTo(targetState,signal);
-      this.logger.info(`Statemanager: ${feedback}`);
-      
-      /* -- Auto pick setpoints in auto mode when operational--*/
-      if (
-          targetState === "operational" &&
-          this.config.mode.current === "auto" &&
-          this.delayedMove !== position &&
-          this.delayedMove
-      ) {
-          this.logger.info(`Automatically picking up on last requested setpoint ${this.delayedMove}`);
-          //trigger move 
-          await this.moveTo(this.delayedMove,signal);
-          this.delayedMove = null;
-
-          this.logger.info(`moveTo : ${feedback} `);
-      }
-
-      this.logger.info(`State change to ${targetState} completed.`);
-      this.emitter.emit('stateChange', targetState); // <-- Implement Here
-    } catch (error) {
-        if (
-        error.message === "Transition aborted" ||
-        error.message === "Movement aborted"
-      ) {
-        throw error;
-      }
-        this.logger.error(error);
-    }
-  }
-
-}
-
-module.exports = state;
-

helper/state/stateConfig.json

@@ -1,331 +0,0 @@
-{
-    "general": {
-      "name": {
-        "default": "State Configuration",
-        "rules": {
-          "type": "string",
-          "description": "A human-readable name for the state configuration."
-        }
-      },
-      "id": {
-        "default": null,
-        "rules": {
-          "type": "string",
-          "nullable": true,
-          "description": "A unique identifier for this configuration, assigned dynamically when needed."
-        }
-      },
-      "unit": {
-        "default": "unitless",
-        "rules": {
-          "type": "string",
-          "description": "The unit used for the state values (e.g., 'meters', 'seconds', 'unitless')."
-        }
-      },
-      "logging": {
-        "logLevel": {
-            "default": "info",
-            "rules": {
-                "type": "enum",
-                "values": [
-                    {
-                        "value": "debug",
-                        "description": "Log messages are printed for debugging purposes."
-                    },
-                    {
-                        "value": "info",
-                        "description": "Informational messages are printed."
-                    },
-                    {
-                        "value": "warn",
-                        "description": "Warning messages are printed."
-                    },
-                    {
-                        "value": "error",
-                        "description": "Error messages are printed."
-                    }
-                ]
-            }
-        },
-        "enabled": {
-            "default": true,
-            "rules": {
-                "type": "boolean",
-                "description": "Indicates whether logging is active. If true, log messages will be generated."
-            }
-        }
-      }
-    },
-    "functionality": {
-      "softwareType": {
-        "default": "state class",
-        "rules": {
-          "type": "string",
-          "description": "Logical name identifying the software type."
-        }
-      },
-      "role": {
-        "default": "StateController",
-        "rules": {
-          "type": "string",
-          "description": "Functional role within the system."
-        }
-      }
-    },
-    "time": {
-      "starting": {
-        "default": 10,
-        "rules": {
-          "type": "number",
-          "description": "Time in seconds for the starting phase."
-        }
-      },
-      "warmingup": {
-        "default": 5,
-        "rules": {
-          "type": "number",
-          "description": "Time in seconds for the warming-up phase."
-        }
-      },
-      "stopping": {
-        "default": 5,
-        "rules": {
-          "type": "number",
-          "description": "Time in seconds for the stopping phase."
-        }
-      },
-      "coolingdown": {
-        "default": 10,
-        "rules": {
-          "type": "number",
-          "description": "Time in seconds for the cooling-down phase."
-        }
-      }
-    },
-    "movement": {
-      "mode": {
-        "default": "dynspeed",
-        "rules": {
-          "type": "enum",
-          "values": [
-            {
-              "value": "staticspeed",
-              "description": "Linear movement to setpoint."
-            },
-            {
-              "value": "dynspeed",
-              "description": "Ease-in and ease-out to setpoint."
-            }
-          ]
-        }
-      },
-      "speed": {
-        "default": 1,
-        "rules": {
-          "type": "number",
-          "description": "Current speed setting."
-        }
-      },
-      "maxSpeed": {
-        "default": 10,
-        "rules": {
-          "type": "number",
-          "description": "Maximum speed setting."
-        }
-      },
-      "interval": {
-        "default": 1000,
-        "rules": {
-          "type": "number",
-          "description": "Feedback interval in milliseconds."
-        }
-      }
-    },
-    "position": {
-      "min": {
-        "default": 0,
-        "rules": {
-          "type": "number",
-          "description": "Minimum position value."
-        }
-      },
-      "max": {
-        "default": 100,
-        "rules": {
-          "type": "number",
-          "description": "Maximum position value."
-        }
-      },
-      "initial": {
-        "default": 0,
-        "rules": {
-          "type": "number",
-          "description": "Initial position value."
-        }
-      }
-    },
-    "state": {
-      "current": {
-        "default": "idle",
-        "rules": {
-          "type": "enum",
-          "values": [
-            {
-              "value": "idle",
-              "description": "Machine is idle."
-            },
-            {
-              "value": "starting",
-              "description": "Machine is starting up."
-            },
-            {
-              "value": "warmingup",
-              "description": "Machine is warming up."
-            },
-            {
-              "value": "operational",
-              "description": "Machine is running."
-            },
-            {
-              "value": "accelerating",
-              "description": "Machine is accelerating."
-            },
-            {
-              "value": "decelerating",
-              "description": "Machine is decelerating."
-            },
-            {
-              "value": "stopping",
-              "description": "Machine is stopping."
-            },
-            {
-              "value": "coolingdown",
-              "description": "Machine is cooling down."
-            },
-            {
-              "value": "off",
-              "description": "Machine is off."
-            }
-          ],
-          "description": "Current state of the machine."
-        }
-      },
-      "allowedTransitions":{
-        "default": {},
-        "rules": {
-          "type": "object",
-          "schema": {
-            "idle": {
-              "default": ["starting", "off","emergencystop"],
-              "rules":{
-                "type": "set",
-                "itemType": "string",
-                "description": "Allowed transitions from idle state."
-              }
-            },
-            "starting": {
-              "default": ["starting","warmingup","emergencystop"],
-              "rules":{
-                "type": "set",
-                "itemType": "string",
-                "description": "Allowed transitions from starting state."
-              }
-            },
-            "warmingup": {
-              "default": ["operational","emergencystop"],
-              "rules":{
-                "type": "set",
-                "itemType": "string",
-                "description": "Allowed transitions from warmingup state."
-              }
-            },
-            "operational": {
-              "default": ["accelerating", "decelerating", "stopping","emergencystop"],
-              "rules":{
-                "type": "set",
-                "itemType": "string",
-                "description": "Allowed transitions from operational state."
-              }
-            },
-            "accelerating": {
-              "default": ["operational","emergencystop"],
-              "rules":{
-                "type": "set",
-                "itemType": "string",
-                "description": "Allowed transitions from accelerating state."
-              }
-            },
-            "decelerating": {
-              "default": ["operational","emergencystop"],
-              "rules":{
-                "type": "set",
-                "itemType": "string",
-                "description": "Allowed transitions from decelerating state."
-              }
-            },
-            "stopping": {
-              "default": ["idle","coolingdown","emergencystop"],
-              "rules":{
-                "type": "set",
-                "itemType": "string",
-                "description": "Allowed transitions from stopping state."
-              }
-            },
-            "coolingdown": {
-              "default": ["idle","off","emergencystop"],
-              "rules":{
-                "type": "set",
-                "itemType": "string",
-                "description": "Allowed transitions from coolingDown state."
-              }
-            },
-            "off": {
-              "default": ["idle","emergencystop"],
-              "rules":{
-                "type": "set",
-                "itemType": "string",
-                "description": "Allowed transitions from off state."
-              }
-          },
-          "emergencystop": {
-            "default": ["idle","off"],
-            "rules":{
-              "type": "set",
-              "itemType": "string",
-              "description": "Allowed transitions from emergency stop state."
-            }
-          }
-        },
-        "description": "Allowed transitions between states."
-        }
-      },
-      "activeStates":{ 
-        "default": ["operational", "starting", "warmingup", "accelerating", "decelerating"],
-        "rules": {
-          "type": "set",
-          "itemType": "string",
-          "description": "Active states."
-        }
-      }
-    },
-    "mode": {
-      "current": {
-        "default": "auto",
-        "rules": {
-          "type": "enum",
-          "values": [
-            {
-              "value": "auto",
-              "description": "Automatically tracks and handles delayed commands for setpoints > 0."
-            },
-            {
-              "value": "manual",
-              "description": "Requires explicit commands to start."
-            }
-          ],
-          "description": "Current mode of the machine."
-        }
-      }
-      }
-  }
-  

helper/state/stateManager.js

@@ -1,164 +0,0 @@
-/**
- * @file stateManager.js
- *
- * Permission is hereby granted to any person obtaining a copy of this software
- * and associated documentation files (the "Software"), to use it for personal
- * or non-commercial purposes, with the following restrictions:
- *
- * 1. **No Copying or Redistribution**: The Software or any of its parts may not
- *    be copied, merged, distributed, sublicensed, or sold without explicit
- *    prior written permission from the author.
- *
- * 2. **Commercial Use**: Any use of the Software for commercial purposes requires
- *    a valid license, obtainable only with the explicit consent of the author.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
- * OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Ownership of this code remains solely with the original author. Unauthorized
- * use of this Software is strictly prohibited.
- *
- * @summary Class for managing state transitions and state descriptions.
- * @description Class for managing state transitions and state descriptions.
- * @module stateManager
- * @exports stateManager
- * @version 0.1.0
- * @since 0.1.0
- *
- * Author:
- * - Rene De Ren
- * Email:
- * - rene@thegoldenbasket.nl
- */
-
-class stateManager {
-  constructor(config, logger) {
-    this.currentState = config.state.current;
-    this.availableStates = config.state.available;
-    this.descriptions = config.state.descriptions;
-    this.logger = logger;
-    this.transitionTimeleft = 0;
-    this.transitionTimes = config.time;
-
-    // Define valid transitions (can be extended dynamically if needed)
-    this.validTransitions = config.state.allowedTransitions;
-
-    // NEW: Initialize runtime tracking
-    this.runTimeHours = 0; // cumulative runtime in hours
-    this.runTimeStart = null; // timestamp when active state began
-
-    // Define active states (runtime counts only in these states)
-    this.activeStates = config.state.activeStates;
-  }
-
-  getCurrentState() {
-    return this.currentState;
-  }
-
-  transitionTo(newState,signal) {
-    return new Promise((resolve, reject) => {
-      if (signal && signal.aborted) {
-        this.logger.debug("Transition aborted.");
-        return reject("Transition aborted.");
-      }
-
-      if (!this.isValidTransition(newState)) {
-        return reject(
-          `Invalid transition from ${this.currentState} to ${newState}. Transition not executed.`
-        ); //go back early and reject promise
-      }
-
-      // NEW: Handle runtime tracking based on active states
-      this.handleRuntimeTracking(newState);
-
-      const transitionDuration = this.transitionTimes[this.currentState] || 0; // Default to 0 if no transition time
-      this.logger.debug(
-        `Transition from ${this.currentState} to ${newState} will take ${transitionDuration}s.`
-      );
-
-      if (transitionDuration > 0) {
-        const timeoutId = setTimeout(() => {
-          this.currentState = newState;
-          resolve(`Transition from ${this.currentState} to ${newState} completed in ${transitionDuration}s.`);
-        }, transitionDuration * 1000);
-        if (signal) {
-          signal.addEventListener('abort', () => {
-            clearTimeout(timeoutId);
-            reject(new Error('Transition aborted'));
-          });
-        }
-      } else {
-        this.currentState = newState;
-        resolve(`Immediate transition to ${this.currentState} completed.`);
-      }
-    });
-  }
-
-  handleRuntimeTracking(newState) {
-    // NEW: Handle runtime tracking based on active states
-    const wasActive = this.activeStates.has(this.currentState);
-    const willBeActive = this.activeStates.has(newState);
-    if (wasActive && !willBeActive && this.runTimeStart) {
-      // stop runtime timer and accumulate elapsed time
-      const elapsed = (Date.now() - this.runTimeStart) / 3600000; // hours
-      this.runTimeHours += elapsed;
-      this.runTimeStart = null;
-      this.logger.debug(
-        `Runtime timer stopped; elapsed=${elapsed.toFixed(
-          3
-        )}h, total=${this.runTimeHours.toFixed(3)}h.`
-      );
-    } else if (!wasActive && willBeActive && !this.runTimeStart) {
-      // starting new runtime
-      this.runTimeStart = Date.now();
-      this.logger.debug("Runtime timer started.");
-    }
-  }
-
-  isValidTransition(newState) {
-    this.logger.debug(
-      `Check 1 Transition valid ? From ${
-        this.currentState
-      } To ${newState} => ${this.validTransitions[this.currentState]?.has(
-        newState
-      )} `
-    );
-    this.logger.debug(
-      `Check 2 Transition valid ? ${
-        this.currentState
-      } is not equal to ${newState} => ${this.currentState !== newState}`
-    );
-    // check if transition is valid and not the same as before
-    const valid =
-      this.validTransitions[this.currentState]?.has(newState) &&
-      this.currentState !== newState;
-
-    //if not valid
-    if (!valid) {
-      return false;
-    } else {
-      return true;
-    }
-  }
-
-  getStateDescription(state = this.currentState) {
-    return this.descriptions[state] || "No description available.";
-  }
-
-  // NEW: Getter to retrieve current cumulative runtime (active time) in hours.
-  getRunTimeHours() {
-    // If currently active add the ongoing duration.
-    let currentElapsed = 0;
-    if (this.runTimeStart) {
-      currentElapsed = (Date.now() - this.runTimeStart) / 3600000;
-    }
-    return this.runTimeHours + currentElapsed;
-  }
-}
-
-module.exports = stateManager;

helper/validationUtils.js

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

index.js

@@ -3,68 +3,44 @@
  * -----------------------------------------------------------
  * Central barrel file for re-exporting helpers and configurations.
  * Provides both namespace exports and dynamic loading capabilities.
+ * now we can load modules like this:
+ * const { menuUtils, outputUtils } = require('generalFunctions');
  */
 
 // Core helper modules
-const menuUtils = require('./src/helper/menuUtils.js');
+const outputUtils = require('./src/helper/outputUtils.js');
 const logger = require('./src/helper/logger.js');
 const validation = require('./src/helper/validationUtils.js');
+const configUtils = require('./src/helper/configUtils.js');
+const assertions = require('./src/helper/assertionUtils.js')
 
 // Domain-specific modules
-const measurements = require('./src/measurements/index.js');
+const { MeasurementContainer } = require('./src/measurements/index.js');
-const nrmse = require('./src/nrmse/index.js');
+const configManager = require('./src/configs/index.js');
-const state = require('./src/state/index.js');
+const nrmse = require('./src/nrmse/errorMetrics.js');
-
+const state = require('./src/state/state.js');
-// Configuration loader with error handling
+const convert = require('./src/convert/index.js');
-function loadConfig(path) {
+const MenuManager = require('./src/menu/index.js');
-    try {
+const predict = require('./src/predict/predict_class.js');
-        return require(path);
+const interpolation = require('./src/predict/interpolation.js');
-    } catch (error) {
+const childRegistrationUtils = require('./src/helper/childRegistrationUtils.js');
-        console.warn(`Failed to load config: ${path}`, error);
+const { loadCurve } = require('./datasets/assetData/curves/index.js');
-        return null;
-    }
-}
-
-// Configurations
-const configs = {
-    get projectSettings() {
-        return loadConfig('./configs/projectSettings.json');
-    },
-    get measurementConfig() {
-        return loadConfig('./configs/measurementConfig.json');
-    }
-};
-
-// Dynamic loaders with validation
-function loadHelper(name) {
-    if (!name || typeof name !== 'string') {
-        throw new Error('Helper name must be a non-empty string');
-    }
-    
-    try {
-        return require(`./src/helper/${name}.js`);
-    } catch (error) {
-        throw new Error(`Failed to load helper "${name}": ${error.message}`);
-    }
-}
-
-function loadAssetDatasets() {
-    try {
-        return require('./datasets/assetData/suppliers.json');
-    } catch (error) {
-        throw new Error(`Failed to load asset datasets: ${error.message}`);
-    }
-}
 
 // Export everything
 module.exports = {
-    menuUtils,
+    predict,
+    interpolation,
+    configManager,
+    outputUtils,
+    configUtils,
     logger,
     validation,
-    measurements,
+    assertions,
+    MeasurementContainer,
     nrmse,
     state,
-    configs,
+    convert,
-    loadHelper,
+    MenuManager,
-    loadAssetDatasets
+    childRegistrationUtils,
+    loadCurve
 };

src/configs/index.js

@@ -0,0 +1,76 @@
+const fs = require('fs');
+const path = require('path');
+
+class ConfigManager {
+    constructor(relPath = '.') {
+        this.configDir = path.resolve(__dirname, relPath);
+    }
+
+    /**
+     * Load a configuration file by name
+     * @param {string} configName - Name of the config file (without .json extension)
+     * @returns {Object} Parsed configuration object
+     */
+    getConfig(configName) {
+        try {
+            const configPath = path.resolve(this.configDir, `${configName}.json`);
+            const configData = fs.readFileSync(configPath, 'utf8');
+            return JSON.parse(configData);
+        } catch (error) {
+            throw new Error(`Failed to load config '${configName}': ${error.message}`);
+        }
+    }
+
+    /**
+     * Get list of available configuration files
+     * @returns {Array<string>} Array of config names (without .json extension)
+     */
+    getAvailableConfigs() {
+        try {
+            const resolvedDir = path.resolve(this.configDir);
+            const files = fs.readdirSync(resolvedDir);
+            return files
+                .filter(file => file.endsWith('.json'))
+                .map(file => path.basename(file, '.json'));
+        } catch (error) {
+            throw new Error(`Failed to read config directory: ${error.message}`);
+        }
+    }
+
+    /**
+     * Check if a specific config exists
+     * @param {string} configName - Name of the config file
+     * @returns {boolean} True if config exists
+     */
+    hasConfig(configName) {
+        const configPath = path.resolve(this.configDir, `${configName}.json`);
+        return fs.existsSync(configPath);
+    }
+
+        createEndpoint(nodeName) {
+            try {
+                // Load the config for this node
+                const config = this.getConfig(nodeName);
+                
+                // Convert config to JSON
+                const configJSON = JSON.stringify(config, null, 2);
+
+                // Assemble the complete script
+                return `
+                // Create the namespace structure
+                window.EVOLV = window.EVOLV || {};
+                window.EVOLV.nodes = window.EVOLV.nodes || {};
+                window.EVOLV.nodes.${nodeName} = window.EVOLV.nodes.${nodeName} || {};
+
+                // Inject the pre-loaded config data directly into the namespace
+                window.EVOLV.nodes.${nodeName}.config = ${configJSON};
+
+                console.log('${nodeName} config loaded and endpoint created');
+                `;
+            } catch (error) {
+                throw new Error(`Failed to create endpoint for '${nodeName}': ${error.message}`);
+            }
+        }
+}
+
+module.exports = ConfigManager;

src/configs/machineGroupControl.json

@@ -0,0 +1,216 @@
+{
+    "general": {
+      "name": {
+        "default": "Machine Group Configuration",
+        "rules": {
+          "type": "string",
+          "description": "A human-readable name or label for this machine group configuration."
+        }
+      },
+      "id": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "A unique identifier for this configuration. If not provided, defaults to null."
+        }
+      },
+        "unit": {
+        "default": "m3/h",
+        "rules": {
+          "type": "string",
+          "description": "The default measurement unit for this configuration (e.g., 'meters', 'seconds', 'unitless')."
+        }
+      },
+      "logging": {
+        "logLevel": {
+          "default": "info",
+          "rules": {
+            "type": "enum",
+            "values": [
+              {
+                "value": "debug",
+                "description": "Log messages are printed for debugging purposes."
+              },
+              {
+                "value": "info",
+                "description": "Informational messages are printed."
+              },
+              {
+                "value": "warn",
+                "description": "Warning messages are printed."
+              },
+              {
+                "value": "error",
+                "description": "Error messages are printed."
+              }
+            ]
+          }
+        },
+        "enabled": {
+          "default": true,
+          "rules": {
+            "type": "boolean",
+            "description": "Indicates whether logging is active. If true, log messages will be generated."
+          }
+        }
+      }
+    },
+    "functionality": {
+      "softwareType": {
+        "default": "machineGroup",
+        "rules": {
+          "type": "string",
+          "description": "Logical name identifying the software type."
+        }
+      },
+      "role": {
+        "default": "GroupController",
+        "rules": {
+          "type": "string",
+          "description": "Controls a group of machines within the system."
+        }
+      },
+      "positionVsParent":{
+            "default":"atEquipment",
+            "rules": {
+                "type": "enum",
+                "values": [
+                    {
+                        "value": "atEquipment",
+                        "description": "The node is connected at the equipment level and is responsible for controlling or monitoring the equipment as a whole."
+                    },
+                    {
+                        "value": "upstream",
+                        "description": "The node is connected in a downstream position, indicating it is responsible for monitoring or controlling processes that occur after the equipment's operation, such as product flow or output."
+                    },
+                    {
+                        "value": "downstream",
+                        "description": "The node is connected in an upstream position, indicating it is responsible for monitoring or controlling processes that occur before the equipment's operation, such as input flow or supply."
+                    }
+                ],
+                "description": "Defines the position of the measurement relative to its parent equipment or system."
+            }
+        }
+    },
+    "mode": {
+        "current": {
+          "default": "optimalControl",
+          "rules": {
+            "type": "enum",
+            "values": [
+              {
+                "value": "optimalControl",
+                "description": "The group controller selects the most optimal combination of machines based on their real-time performance curves."
+              },
+              {
+                "value": "priorityControl",
+                "description": "Machines are controlled sequentially from minimum to maximum output until each is maxed out, then additional machines are added."
+              },
+              {
+                "value": "prioritypercentagecontrol",
+                "description": "Machines are controlled sequentially from minimum to maximum output until each is maxed out, then additional machines are added based on a percentage of the total demand."
+              },
+              {
+                "value": "maintenance",
+                "description": "The group is in maintenance mode with limited actions (monitoring only)."
+              }
+            ],
+            "description": "The operational mode of the machine group controller."
+          }
+        },
+        "allowedActions": {
+          "default": {},
+          "rules": {
+            "type": "object",
+            "schema": {
+              "optimalControl": {
+                "default": ["statusCheck", "execOptimalCombination", "balanceLoad", "emergencyStop"],
+                "rules": {
+                  "type": "set",
+                  "itemType": "string",
+                  "description": "Actions allowed in optimalControl mode."
+                }
+              },
+              "priorityControl": {
+                "default": ["statusCheck", "execSequentialControl", "balanceLoad", "emergencyStop"],
+                "rules": {
+                  "type": "set",
+                  "itemType": "string",
+                  "description": "Actions allowed in priorityControl mode."
+                }
+              },
+              "prioritypercentagecontrol": {
+                "default": ["statusCheck", "execSequentialControl", "balanceLoad", "emergencyStop"],
+                "rules": {
+                  "type": "set",
+                  "itemType": "string",
+                  "description": "Actions allowed in manualOverride mode."
+                }
+              },
+              "maintenance": {
+                "default": ["statusCheck"],
+                "rules": {
+                  "type": "set",
+                  "itemType": "string",
+                  "description": "Actions allowed in maintenance mode."
+                }
+              }
+            },
+            "description": "Defines the actions available for each operational mode of the machine group controller."
+          }
+        },
+        "allowedSources": {
+          "default": {},
+          "rules": {
+            "type": "object",
+            "schema": {
+              "optimalcontrol": {
+                "default": ["parent", "GUI", "physical", "API"],
+                "rules": {
+                  "type": "set",
+                  "itemType": "string",
+                  "description": "Command sources allowed in optimalControl mode."
+                }
+              },
+              "prioritycontrol": {
+                "default": ["parent", "GUI", "physical", "API"],
+                "rules": {
+                  "type": "set",
+                  "itemType": "string",
+                  "description": "Command sources allowed in priorityControl mode."
+                }
+              },
+              "prioritypercentagecontrol": {
+                "default": ["parent", "GUI", "physical", "API"],
+                "rules": {
+                  "type": "set",
+                  "itemType": "string",
+                  "description": "Command sources allowed "
+                }
+              }
+            },
+            "description": "Specifies the valid command sources recognized by the machine group controller for each mode."
+          }
+        }
+    },
+    "scaling": {
+      "current": {
+        "default": "normalized",
+        "rules": {
+          "type": "enum",
+          "values": [
+            {
+              "value": "normalized",
+              "description": "Scales the demand between 0–100% of the total flow capacity, interpolating to calculate the effective demand."
+            },
+            {
+              "value": "absolute",
+              "description": "Uses the absolute demand value directly, capped between the min and max machine flow capacities."
+            }
+          ],
+          "description": "The scaling mode for demand calculations."
+        }
+      }
+    }
+  }

src/configs/measurement.json

@@ -1,7 +1,7 @@
 {
     "general": {
         "name": {
-            "default": "Measurement Configuration",
+            "default": "Sensor",
             "rules": {
                 "type": "string",
                 "description": "A human-readable name or label for this measurement configuration."
@@ -70,6 +70,34 @@
                 "type": "string",
                 "description": "Indicates the role this configuration plays (e.g., sensor, controller, etc.)."
             }
+        },
+        "positionVsParent":{
+            "default":"atEquipment",
+            "rules": {
+                "type": "enum",
+                "values": [
+                    {
+                        "value": "atEquipment",
+                        "description": "The measurement is taken at the equipment level, typically representing the overall state or performance of the equipment."
+                    },
+                    {
+                        "value": "upstream",
+                        "description": "The measurement is taken upstream, meaning it is related to inputs or conditions that affect the equipment's operation, such as supply conditions or environmental factors."
+                    },
+                    {
+                        "value": "downstream",
+                        "description": "The measurement is taken downstream, indicating it relates to outputs or results of the equipment's operation, such as product quality or performance metrics."
+                    }
+                ],
+                "description": "Defines the position of the measurement relative to its parent equipment or system."
+            }
+        },
+        "distance":{
+            "default": null,
+            "rules": {
+                "type": "number",
+                "description": "Defines the position of the measurement relative to its parent equipment or system."
+            }
         }
     },
     "asset": {
@@ -81,6 +109,14 @@
                 "description": "Asset tag number which is a universally unique identifier for this asset. May be null if not assigned."
             }
         },
+        "tagCode":{
+            "default": null,
+            "rules": {
+                "type": "string",
+                "nullable": true,
+                "description": "Asset tag code which is a unique identifier for this asset. May be null if not assigned."
+            }
+        },
         "geoLocation": {
             "default": {
                 "x": 0,
@@ -122,7 +158,7 @@
                 "description": "The supplier or manufacturer of the asset."
             }
         },
-        "type": {
+        "category": {
             "default": "sensor",
             "rules": {
                 "type": "enum",
@@ -134,7 +170,7 @@
                 ]
             }
         },
-        "subType": {
+        "type": {
             "default": "pressure",
             "rules": {
                 "type": "string",
@@ -148,6 +184,13 @@
                 "description": "A user-defined or manufacturer-defined model identifier for the asset."
             }
         },
+        "unit": {
+            "default": "unitless",
+            "rules": {
+                "type": "string",
+                "description": "The unit of measurement for this asset (e.g., 'meters', 'seconds', 'unitless')."
+            }
+        },
         "accuracy": {
             "default": null,
             "rules": {

src/configs/rotatingMachine.json

@@ -70,6 +70,27 @@
           "type": "string",
           "description": "Indicates the role this configuration plays within the system."
         }
+      },
+      "positionVsParent":{
+            "default":"atEquipment",
+            "rules": {
+                "type": "enum",
+                "values": [
+                    {
+                        "value": "atEquipment",
+                        "description": "The node is connected at the equipment level and is responsible for controlling or monitoring the equipment as a whole."
+                    },
+                    {
+                        "value": "upstream",
+                        "description": "The node is connected in a downstream position, indicating it is responsible for monitoring or controlling processes that occur after the equipment's operation, such as product flow or output."
+                    },
+                    {
+                        "value": "downstream",
+                        "description": "The node is connected in an upstream position, indicating it is responsible for monitoring or controlling processes that occur before the equipment's operation, such as input flow or supply."
+                    }
+                ],
+                "description": "Defines the position of the measurement relative to its parent equipment or system."
+            }
         }
     },
     "asset": {
@@ -81,6 +102,14 @@
           "description": "A universally unique identifier for this asset. May be null if not assigned."
         }
       },
+      "tagCode":{
+            "default": null,
+            "rules": {
+                "type": "string",
+                "nullable": true,
+                "description": "Asset tag code which is a unique identifier for this asset. May be null if not assigned."
+            }
+        },
       "geoLocation": {
         "default": {},
         "rules": {
@@ -118,14 +147,14 @@
           "description": "The supplier or manufacturer of the asset."
         }
       },
-      "type": {
+      "category": {
         "default": "pump",
         "rules": {
           "type": "string",
           "description": "A general classification of the asset tied to the specific software. This is not chosen from the asset dropdown menu."
         }
       },
-      "subType": {
+      "type": {
         "default": "Centrifugal",
         "rules": {
           "type": "string",
@@ -139,6 +168,13 @@
           "description": "A user-defined or manufacturer-defined model identifier for the asset."
         }
       },
+      "unit": {
+            "default": "unitless",
+            "rules": {
+                "type": "string",
+                "description": "The unit of measurement for this asset (e.g., 'meters', 'seconds', 'unitless')."
+            }
+        },
       "accuracy": {
         "default": null,
         "rules": {
@@ -314,31 +350,6 @@
         "description": "Information about valid command sources recognized by the machine."
       }
     },
-    "action": {
-      "default": "statusCheck",
-      "rules": {
-        "type": "enum",
-        "values": [
-          {
-            "value": "statusCheck",
-            "description": "Checks the machine's state (mode, submode, operational status)."
-          },
-          {
-            "value": "execMovement",
-            "description": "Allows control through auto or GUI setpoints."
-          },
-          {
-            "value": "execSequence",
-            "description": "Allows execution of sequences through auto or GUI controls."
-          },
-          {
-            "value": "emergencyStop",
-            "description": "Overrides all commands and stops the machine immediately (safety scenarios)."
-          }
-        ],
-        "description": "Defines the possible actions that can be performed on the machine."
-      }
-    },
     "sequences":{
       "default":{},
       "rules": {
@@ -401,6 +412,14 @@
         ],
         "description": "The frequency at which calculations are performed."
       }
+    },
+    "flowNumber": {
+      "default": 1,
+      "rules": {
+        "type": "number",
+        "nullable": false,
+        "description": "Defines which effluent flow of the parent node to handle."
+      }
     }
   }
   

src/configs/valve.json

@@ -0,0 +1,387 @@
+{
+    "general": {
+      "name": {
+        "default": "valve",
+        "rules": {
+          "type": "string",
+          "description": "A human-readable name or label for this machine configuration."
+        }
+      },
+      "id": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "A unique identifier for this configuration. If not provided, defaults to null."
+        }
+      },
+      "unit": {
+        "default": "m3/h",
+        "rules": {
+          "type": "string",
+          "description": "The default measurement unit for this configuration (e.g., 'meters', 'seconds', 'unitless')."
+        }
+      },
+      "logging": {
+        "logLevel": {
+          "default": "info",
+          "rules": {
+            "type": "enum",
+            "values": [
+              {
+                "value": "debug",
+                "description": "Log messages are printed for debugging purposes."
+              },
+              {
+                "value": "info",
+                "description": "Informational messages are printed."
+              },
+              {
+                "value": "warn",
+                "description": "Warning messages are printed."
+              },
+              {
+                "value": "error",
+                "description": "Error messages are printed."
+              }
+            ]
+          }
+        },
+        "enabled": {
+          "default": true,
+          "rules": {
+            "type": "boolean",
+            "description": "Indicates whether logging is active. If true, log messages will be generated."
+          }
+        }
+      }
+    },
+    "functionality": {
+      "softwareType": {
+        "default": "valve",
+          "rules": {
+            "type": "string",
+            "description": "Specified software type for this configuration."
+        }
+      },
+      "role": {
+        "default": "controller",
+        "rules": {
+          "type": "string",
+          "description": "Indicates the role this configuration plays within the system."
+        }
+      },
+      "positionVsParent":{
+            "default":"atEquipment",
+            "rules": {
+                "type": "enum",
+                "values": [
+                    {
+                        "value": "atEquipment",
+                        "description": "The node is connected at the equipment level and is responsible for controlling or monitoring the equipment as a whole."
+                    },
+                    {
+                        "value": "upstream",
+                        "description": "The node is connected in a downstream position, indicating it is responsible for monitoring or controlling processes that occur after the equipment's operation, such as product flow or output."
+                    },
+                    {
+                        "value": "downstream",
+                        "description": "The node is connected in an upstream position, indicating it is responsible for monitoring or controlling processes that occur before the equipment's operation, such as input flow or supply."
+                    }
+                ],
+                "description": "Defines the position of the measurement relative to its parent equipment or system."
+            }
+        }
+    },
+    "asset": {
+      "uuid": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "A universally unique identifier for this asset. May be null if not assigned."
+        }
+      },
+      "tagCode":{
+            "default": null,
+            "rules": {
+                "type": "string",
+                "nullable": true,
+                "description": "Asset tag code which is a unique identifier for this asset. May be null if not assigned."
+            }
+        },
+      "geoLocation": {
+        "default": {},
+        "rules": {
+          "type": "object",
+          "description": "An object representing the asset's physical coordinates or location.",
+          "schema": {
+            "x": {
+              "default": 0,
+              "rules": {
+                "type": "number",
+                "description": "X coordinate of the asset's location."
+              }
+            },
+            "y": {
+              "default": 0,
+              "rules": {
+                "type": "number",
+                "description": "Y coordinate of the asset's location."
+              }
+            },
+            "z": {
+              "default": 0,
+              "rules": {
+                "type": "number",
+                "description": "Z coordinate of the asset's location."
+              }
+            }
+          }
+        }
+      },
+      "supplier": {
+        "default": "Unknown",
+        "rules": {
+          "type": "string",
+          "description": "The supplier or manufacturer of the asset."
+        }
+      },
+      "category": {
+        "default": "valve",
+        "rules": {
+          "type": "string",
+          "description": "A general classification of the asset tied to the specific software. This is not chosen from the asset dropdown menu."
+        }
+      },
+      "type": {
+        "default": "gate",
+        "rules": {
+          "type": "string",
+          "description": "A more specific classification within 'type'. For example, 'centrifugal' for a centrifugal pump."
+        }
+      },
+      "model": {
+        "default": "Unknown",
+        "rules": {
+          "type": "string",
+          "description": "A user-defined or manufacturer-defined model identifier for the asset."
+        }
+      },
+      "unit": {
+            "default": "unitless",
+            "rules": {
+                "type": "string",
+                "description": "The unit of measurement for this asset (e.g., 'meters', 'seconds', 'unitless')."
+            }
+        },
+      "accuracy": {
+        "default": null,
+        "rules": {
+          "type": "number",
+          "nullable": true,
+          "description": "The accuracy of the machine or sensor, typically as a percentage or absolute value."
+        }
+      },
+      "valveCurve": {
+        "default": {
+          "1.204": {
+              "1": {
+                  "x": [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100],
+                  "y": [0, 18, 50, 95, 150, 216, 337, 564, 882, 1398, 1870]
+              }
+            }
+          },
+        "rules": {
+            "type": "valveCurve",
+            "description": "the first parameter is kg (usually according to 1 normal cubic meter per hour acc. to din norm ) and the second parameter is the diameter in mm. The x values are the opening of the valve in percent and the y values are the KV values in m3/h. The KV value is the flow rate of water at a temperature of 20 degrees Celsius through the valve when it is fully open."
+        }
+      }
+    },
+    "mode": {
+      "current": {
+        "default": "auto",
+        "rules": {
+          "type": "enum",
+          "values": [
+            {
+              "value": "auto",
+              "description": "Machine accepts setpoints from a parent controller and runs autonomously."
+            },
+            {
+              "value": "virtualControl",
+              "description": "Controlled via GUI setpoints; ignores parent commands."
+            },
+            {
+              "value": "fysicalControl",
+              "description": "Controlled via physical buttons or switches; ignores external automated commands."
+            },
+            {
+              "value": "maintenance",
+              "description": "No active control from auto, virtual, or fysical sources."
+            }
+          ],
+          "description": "The operational mode of the machine."
+        }
+      },
+      "allowedActions":{
+        "default":{},
+        "rules": {
+          "type": "object",
+          "schema":{
+            "auto": {
+              "default": ["statusCheck", "execMovement", "execSequence", "emergencyStop"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Actions allowed in auto mode."
+              }
+            },
+            "virtualControl": {
+              "default": ["statusCheck", "execMovement", "execSequence", "emergencyStop"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Actions allowed in virtualControl mode."
+              }
+            },
+            "fysicalControl": {
+              "default": ["statusCheck", "emergencyStop"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Actions allowed in fysicalControl mode."
+              }
+            },
+            "maintenance": {
+              "default": ["statusCheck"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Actions allowed in maintenance mode."
+              }
+            }
+          },
+          "description": "Information about valid command sources recognized by the machine."
+        }
+      },
+      "allowedSources":{
+        "default": {},
+        "rules": {
+          "type": "object",
+          "schema":{
+            "auto": {
+              "default": ["parent", "GUI", "fysical"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Sources allowed in auto mode."
+              }
+            },
+            "virtualControl": {
+              "default": ["GUI", "fysical"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Sources allowed in virtualControl mode."
+              }
+            },
+            "fysicalControl": {
+              "default": ["fysical"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Sources allowed in fysicalControl mode."
+              }
+            }
+          },
+          "description": "Information about valid command sources recognized by the machine."
+        }
+      }
+    },
+    "source": {
+      "default": "parent",
+      "rules": {
+        "type": "enum",
+        "values": [
+          {
+            "value": "parent",
+            "description": "Commands are received from a parent controller."
+          },
+          {
+            "value": "GUI",
+            "description": "Commands are received from a graphical user interface."
+          },
+          {
+            "value": "fysical",
+            "description": "Commands are received from physical buttons or switches."
+          }
+        ],
+        "description": "Information about valid command sources recognized by the machine."
+      }
+    },
+    "sequences":{
+      "default":{},
+      "rules": {
+        "type": "object",
+        "schema": {
+          "startup": {
+            "default": ["starting","warmingup","operational"],
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states for starting up the machine."
+            }
+          },
+          "shutdown": {
+            "default": ["stopping","coolingdown","idle"],
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states for shutting down the machine."
+            }
+          },
+          "emergencystop": {
+            "default": ["emergencystop","off"],
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states for an emergency stop."
+            }
+          },
+          "boot": {
+            "default": ["idle","starting","warmingup","operational"],	
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states for booting up the machine."
+            }
+          }
+        }
+      },
+      "description": "Predefined sequences of states for the machine."
+
+    },
+    "calculationMode": {
+      "default": "medium",
+      "rules": {
+        "type": "enum",
+        "values": [
+          {
+            "value": "low",
+            "description": "Calculations run at fixed intervals (time-based)."
+          },
+          {
+            "value": "medium",
+            "description": "Calculations run when new setpoints arrive or measured changes occur (event-driven)."
+          },
+          {
+            "value": "high",
+            "description": "Calculations run on all event-driven info, including every movement."
+          }
+        ],
+        "description": "The frequency at which calculations are performed."
+      }
+    }
+  }
+  

src/configs/valveGroupControl.json

@@ -0,0 +1,371 @@
+{
+    "general": {
+      "name": {
+        "default": "ValveGroupControl",
+        "rules": {
+          "type": "string",
+          "description": "A human-readable name or label for this valveGroupControl configuration."
+        }
+      },
+      "id": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "A unique identifier for this configuration. If not provided, defaults to null."
+        }
+      },
+      "unit": {
+        "default": "unitless",
+        "rules": {
+          "type": "string",
+          "description": "The default measurement unit for this configuration (e.g., 'meters', 'seconds', 'unitless')."
+        }
+      },
+
+      
+      "logging": {
+        "logLevel": {
+          "default": "info",
+          "rules": {
+            "type": "enum",
+            "values": [
+              {
+                "value": "debug",
+                "description": "Log messages are printed for debugging purposes."
+              },
+              {
+                "value": "info",
+                "description": "Informational messages are printed."
+              },
+              {
+                "value": "warn",
+                "description": "Warning messages are printed."
+              },
+              {
+                "value": "error",
+                "description": "Error messages are printed."
+              }
+            ]
+          }
+        },
+        "enabled": {
+          "default": true,
+          "rules": {
+            "type": "boolean",
+            "description": "Indicates whether logging is active. If true, log messages will be generated."
+          }
+        }
+      }
+    },
+    "functionality": {
+      "softwareType": {
+        "default": "valveGroupControl",
+          "rules": {
+            "type": "string",
+            "description": "Specified software type for this configuration."
+        }
+      },
+      "role": {
+        "default": "ValveGroupController",
+        "rules": {
+          "type": "string",
+          "description": "Indicates the role this configuration plays within the system."
+        }
+      }
+    },
+    "asset": {
+      "uuid": {
+        "default": null,
+        "rules": {
+          "type": "string",
+          "nullable": true,
+          "description": "A universally unique identifier for this asset. May be null if not assigned."
+        }
+      },
+      "geoLocation": {
+        "default": {},
+        "rules": {
+          "type": "object",
+          "description": "An object representing the asset's physical coordinates or location.",
+          "schema": {
+            "x": {
+              "default": 0,
+              "rules": {
+                "type": "number",
+                "description": "X coordinate of the asset's location."
+              }
+            },
+            "y": {
+              "default": 0,
+              "rules": {
+                "type": "number",
+                "description": "Y coordinate of the asset's location."
+              }
+            },
+            "z": {
+              "default": 0,
+              "rules": {
+                "type": "number",
+                "description": "Z coordinate of the asset's location."
+              }
+            }
+          }
+        }
+      },
+      "supplier": {
+        "default": "Unknown",
+        "rules": {
+          "type": "string",
+          "description": "The supplier or manufacturer of the asset."
+        }
+      },
+      "type": {
+        "default": "valve",
+        "rules": {
+          "type": "string",
+          "description": "A general classification of the asset tied to the specific software. This is not chosen from the asset dropdown menu."
+        }
+      },
+      "subType": {
+        "default": "Unknown",
+        "rules": {
+          "type": "string",
+          "description": "A more specific classification within 'type'. For example, 'centrifugal' for a centrifugal pump."
+        }
+      },
+      "model": {
+        "default": "Unknown",
+        "rules": {
+          "type": "string",
+          "description": "A user-defined or manufacturer-defined model identifier for the asset."
+        }
+      },
+      "accuracy": {
+        "default": null,
+        "rules": {
+          "type": "number",
+          "nullable": true,
+          "description": "The accuracy of the valve or sensor, typically as a percentage or absolute value."
+        }
+      }    
+    },
+    "mode": {
+      "current": {
+        "default": "auto",
+        "rules": {
+          "type": "enum",
+          "values": [
+            {
+              "value": "auto",
+              "description": "ValveGroupController accepts inputs from a parents and childs and runs autonomously."
+            },
+            {
+              "value": "virtualControl",
+              "description": "Controlled via GUI setpoints; ignores parent commands."
+            },
+            {
+              "value": "fysicalControl",
+              "description": "Controlled via physical buttons or switches; ignores external automated commands."
+            },
+            {
+              "value": "maintenance",
+              "description": "No active control from auto, virtual, or fysical sources."
+            }
+          ],
+          "description": "The operational mode of the valveGroupControl."
+        }
+      },
+      "allowedActions":{
+        "default":{},
+        "rules": {
+          "type": "object",
+          "schema":{
+            "auto": {
+              "default": ["statusCheck", "execSequence", "emergencyStop", "valvePositionChange", "totalFlowChange", "valveDeltaPchange"],  
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Actions allowed in auto mode."
+              }
+            },
+            "virtualControl": {
+              "default": ["statusCheck", "execSequence", "emergencyStop", "valvePositionChange", "totalFlowChange", "valveDeltaPchange"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Actions allowed in virtualControl mode."
+              }
+            },
+            "fysicalControl": {
+              "default": ["statusCheck", "emergencyStop"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Actions allowed in fysicalControl mode."
+              }
+            },
+            "maintenance": {
+              "default": ["statusCheck"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Actions allowed in maintenance mode."
+              }
+            }
+          },
+          "description": "Information about valid command sources recognized by the valve."
+        }
+      },
+      "allowedSources":{
+        "default": {},
+        "rules": {
+          "type": "object",
+          "schema":{
+            "auto": {
+              "default": ["parent", "GUI", "fysical"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Sources allowed in auto mode."
+              }
+            },
+            "virtualControl": {
+              "default": ["GUI", "fysical"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Sources allowed in virtualControl mode."
+              }
+            },
+            "fysicalControl": {
+              "default": ["fysical"],
+              "rules": {
+                "type": "set",
+                "itemType": "string",
+                "description": "Sources allowed in fysicalControl mode."
+              }
+            }
+          },
+          "description": "Information about valid command sources recognized by the valveGroupControl."
+        }
+      }
+    },
+    "source": {
+      "default": "parent",
+      "rules": {
+        "type": "enum",
+        "values": [
+          {
+            "value": "parent",
+            "description": "Commands are received from a parent controller."
+          },
+          {
+            "value": "GUI",
+            "description": "Commands are received from a graphical user interface."
+          },
+          {
+            "value": "fysical",
+            "description": "Commands are received from physical buttons or switches."
+          }
+        ],
+        "description": "Information about valid command sources recognized by the valveGroupControl."
+      }
+    },
+    "action": {
+      "default": "statusCheck",
+      "rules": {
+        "type": "enum",
+        "values": [
+          {
+            "value": "statusCheck",
+            "description": "Checks the valveGroupControl's state (mode, submode, operational status)."
+          },
+          {
+            "value": "valvePositionChange",
+            "description": "If child valve position change, the new flow for each child valve is determined"
+          },
+          {
+            "value": "execSequence",
+            "description": "Allows execution of sequences through auto or GUI controls."
+          },
+          {
+            "value": "totalFlowChange",
+            "description": "If total flow change, the new flow for each child valve is determined"
+          },
+          {
+            "value": "valveDeltaPchange",
+            "description": "If deltaP change, the deltaPmax is determined"
+          },
+          {
+            "value": "emergencyStop",
+            "description": "Overrides all commands and stops the valveGroupControl immediately (safety scenarios)."
+          }
+        ],
+        "description": "Defines the possible actions that can be performed on the valveGroupControl."
+      }
+    },
+    "sequences":{
+      "default":{},
+      "rules": {
+        "type": "object",
+        "schema": {
+          "startup": {
+            "default": ["starting","warmingup","operational"],
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states for starting up the valve."
+            }
+          },
+          "shutdown": {
+            "default": ["stopping","coolingdown","idle"],
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states for shutting down the valveGroupControl."
+            }
+          },
+          "emergencystop": {
+            "default": ["emergencystop","off"],
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states for an emergency stop."
+            }
+          },
+          "boot": {
+            "default": ["idle","starting","warmingup","operational"],	
+            "rules": {
+              "type": "set",
+              "itemType": "string",
+              "description": "Sequence of states for booting up the valveGroupControl."
+            }
+          }
+        }
+      },
+      "description": "Predefined sequences of states for the valveGroupControl."
+
+    },
+    "calculationMode": {
+      "default": "medium",
+      "rules": {
+        "type": "enum",
+        "values": [
+          {
+            "value": "low",
+            "description": "Calculations run at fixed intervals (time-based)."
+          },
+          {
+            "value": "medium",
+            "description": "Calculations run when new setpoints arrive or measured changes occur (event-driven)."
+          },
+          {
+            "value": "high",
+            "description": "Calculations run on all event-driven info, including every movement."
+          }
+        ],
+        "description": "The frequency at which calculations are performed."
+      }
+    }
+  }

src/convert/definitions/angle.js

@@ -0,0 +1,49 @@
+var angle;
+
+angle = {
+  rad: {
+    name: {
+      singular: 'radian'
+    , plural: 'radians'
+    }
+  , to_anchor: 180/Math.PI
+  }
+, deg: {
+    name: {
+      singular: 'degree'
+    , plural: 'degrees'
+    }
+  , to_anchor: 1
+  }
+, grad: {
+    name: {
+      singular: 'gradian'
+    , plural: 'gradians'
+    }
+  , to_anchor: 9/10
+  }
+, arcmin: {
+    name: {
+      singular: 'arcminute'
+    , plural: 'arcminutes'
+    }
+  , to_anchor: 1/60
+  }
+, arcsec: {
+    name: {
+      singular: 'arcsecond'
+    , plural: 'arcseconds'
+    }
+  , to_anchor: 1/3600
+  }
+};
+
+module.exports = {
+  metric: angle
+, _anchors: {
+    metric: {
+      unit: 'deg'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/apparentPower.js

@@ -0,0 +1,49 @@
+var apparentPower;
+
+apparentPower = {
+  VA: {
+    name: {
+      singular: 'Volt-Ampere'
+    , plural: 'Volt-Amperes'
+    }
+  , to_anchor: 1
+  }
+, mVA: {
+    name: {
+      singular: 'Millivolt-Ampere'
+      , plural: 'Millivolt-Amperes'
+    }
+    , to_anchor: .001
+  }
+, kVA: {
+    name: {
+      singular: 'Kilovolt-Ampere'
+    , plural: 'Kilovolt-Amperes'
+    }
+  , to_anchor: 1000
+  }
+, MVA: {
+    name: {
+      singular: 'Megavolt-Ampere'
+    , plural: 'Megavolt-Amperes'
+    }
+  , to_anchor: 1000000
+  }
+, GVA: {
+    name: {
+      singular: 'Gigavolt-Ampere'
+    , plural: 'Gigavolt-Amperes'
+    }
+  , to_anchor: 1000000000
+  }
+};
+
+module.exports = {
+  metric: apparentPower
+, _anchors: {
+    metric: {
+      unit: 'VA'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/area.js

@@ -0,0 +1,93 @@
+var metric
+  , imperial;
+
+metric = {
+  mm2: {
+    name: {
+      singular: 'Square Millimeter'
+    , plural: 'Square Millimeters'
+    }
+  , to_anchor: 1/1000000
+  }
+, cm2: {
+    name: {
+      singular: 'Centimeter'
+    , plural: 'Centimeters'
+    }
+  , to_anchor: 1/10000
+  }
+, m2: {
+    name: {
+      singular: 'Square Meter'
+    , plural: 'Square Meters'
+    }
+  , to_anchor: 1
+  }
+, ha: {
+    name: {
+      singular: 'Hectare'
+    , plural: 'Hectares'
+    }
+  , to_anchor: 10000
+  }
+, km2: {
+    name: {
+      singular: 'Square Kilometer'
+    , plural: 'Square Kilometers'
+    }
+  , to_anchor: 1000000
+  }
+};
+
+imperial = {
+  'in2': {
+    name: {
+      singular: 'Square Inch'
+    , plural: 'Square Inches'
+    }
+  , to_anchor: 1/144
+  }
+, yd2: {
+    name: {
+      singular: 'Square Yard'
+    , plural: 'Square Yards'  
+    }
+  , to_anchor: 9
+  }
+, ft2: {
+    name: {
+      singular: 'Square Foot'
+    , plural: 'Square Feet'
+    }
+  , to_anchor: 1
+  }
+, ac: {
+    name: {
+      singular: 'Acre'
+    , plural: 'Acres'
+    }
+  , to_anchor: 43560
+  }
+, mi2: {
+    name: {
+      singular: 'Square Mile'
+    , plural: 'Square Miles'
+    }
+  , to_anchor: 27878400
+  }
+};
+
+module.exports = {
+  metric: metric
+, imperial: imperial
+, _anchors: {
+    metric: {
+      unit: 'm2'
+    , ratio: 10.7639
+    }
+  , imperial: {
+      unit: 'ft2'
+    , ratio: 1/10.7639
+    }
+  }
+};

src/convert/definitions/current.js

@@ -0,0 +1,35 @@
+var current;
+
+current = {
+  A: {
+    name: {
+      singular: 'Ampere'
+    , plural: 'Amperes'
+    }
+  , to_anchor: 1
+  }
+, mA: {
+    name: {
+      singular: 'Milliampere'
+      , plural: 'Milliamperes'
+    }
+    , to_anchor: .001
+  }
+, kA: {
+    name: {
+      singular: 'Kiloampere'
+    , plural: 'Kiloamperes'
+    }
+  , to_anchor: 1000
+  }
+};
+
+module.exports = {
+  metric: current
+, _anchors: {
+    metric: {
+      unit: 'A'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/digital.js

@@ -0,0 +1,93 @@
+var bits
+  , bytes;
+
+bits = {
+  b: {
+    name: {
+      singular: 'Bit'
+    , plural: 'Bits'
+    }
+  , to_anchor: 1
+  }
+, Kb: {
+    name: {
+      singular: 'Kilobit'
+    , plural: 'Kilobits'
+    }
+  , to_anchor: 1024
+  }
+, Mb: {
+    name: {
+      singular: 'Megabit'
+    , plural: 'Megabits'
+    }
+  , to_anchor: 1048576
+  }
+, Gb: {
+    name: {
+      singular: 'Gigabit'
+    , plural: 'Gigabits'
+    }
+  , to_anchor: 1073741824
+  }
+, Tb: {
+    name: {
+      singular: 'Terabit'
+    , plural: 'Terabits'
+    }
+  , to_anchor: 1099511627776
+  }
+};
+
+bytes = {
+  B: {
+    name: {
+      singular: 'Byte'
+    , plural: 'Bytes'
+    }
+  , to_anchor: 1
+  }
+, KB: {
+    name: {
+      singular: 'Kilobyte'
+    , plural: 'Kilobytes'
+    }
+  , to_anchor: 1024
+  }
+, MB: {
+    name: {
+      singular: 'Megabyte'
+    , plural: 'Megabytes'
+    }
+  , to_anchor: 1048576
+  }
+, GB: {
+    name: {
+      singular: 'Gigabyte'
+    , plural: 'Gigabytes'
+    }
+  , to_anchor: 1073741824
+  }
+, TB: {
+    name: {
+      singular: 'Terabyte'
+    , plural: 'Terabytes'
+    }
+  , to_anchor: 1099511627776
+  }
+};
+
+module.exports = {
+  bits: bits
+, bytes: bytes
+, _anchors: {
+    bits: {
+      unit: 'b'
+    , ratio: 1/8
+    }
+  , bytes: {
+      unit: 'B'
+    , ratio: 8
+    }
+  }
+};

src/convert/definitions/each.js

@@ -0,0 +1,30 @@
+var metric
+  , imperial;
+
+metric = {
+  ea: {
+    name: {
+      singular: 'Each'
+    , plural: 'Each'
+    }
+  , to_anchor: 1
+  },
+  dz: {
+    name: {
+      singular: 'Dozen'
+    , plural: 'Dozens'
+    }
+  , to_anchor: 12
+  }
+};
+
+module.exports = {
+  metric: metric
+, imperial: {}
+, _anchors: {
+    metric: {
+      unit: 'ea'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/energy.js

@@ -0,0 +1,63 @@
+var energy;
+
+energy = {
+  Wh: {
+    name: {
+      singular: 'Watt-hour'
+    , plural: 'Watt-hours'
+    }
+  , to_anchor: 3600
+  }
+, mWh: {
+    name: {
+      singular: 'Milliwatt-hour'
+      , plural: 'Milliwatt-hours'
+    }
+    , to_anchor: 3.6
+  }
+, kWh: {
+    name: {
+      singular: 'Kilowatt-hour'
+    , plural: 'Kilowatt-hours'
+    }
+  , to_anchor: 3600000
+  }
+, MWh: {
+    name: {
+      singular: 'Megawatt-hour'
+    , plural: 'Megawatt-hours'
+    }
+  , to_anchor: 3600000000
+  }
+, GWh: {
+    name: {
+      singular: 'Gigawatt-hour'
+    , plural: 'Gigawatt-hours'
+    }
+  , to_anchor: 3600000000000
+  }
+, J: {
+    name: {
+      singular: 'Joule'
+    , plural: 'Joules'
+    }
+  , to_anchor: 1
+  }
+, kJ: {
+    name: {
+      singular: 'Kilojoule'
+    , plural: 'Kilojoules'
+    }
+  , to_anchor: 1000
+  }
+};
+
+module.exports = {
+  metric: energy
+, _anchors: {
+    metric: {
+      unit: 'J'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/frequency.js

@@ -0,0 +1,78 @@
+var frequency;
+
+frequency = {
+  mHz: {
+    name: {
+      singular: 'millihertz'
+    , plural: 'millihertz'
+    }
+  , to_anchor: 1/1000
+  }
+, Hz: {
+    name: {
+      singular: 'hertz'
+    , plural: 'hertz'
+    }
+  , to_anchor: 1
+  }
+, kHz: {
+    name: {
+      singular: 'kilohertz'
+    , plural: 'kilohertz'
+    }
+  , to_anchor: 1000
+  }
+, MHz: {
+    name: {
+      singular: 'megahertz'
+    , plural: 'megahertz'
+    }
+  , to_anchor: 1000 * 1000
+  }
+, GHz: {
+    name: {
+      singular: 'gigahertz'
+    , plural: 'gigahertz'
+    }
+  , to_anchor: 1000 * 1000 * 1000
+  }
+, THz: {
+    name: {
+      singular: 'terahertz'
+    , plural: 'terahertz'
+    }
+  , to_anchor: 1000 * 1000 * 1000 * 1000
+  }
+, rpm: {
+    name: {
+      singular: 'rotation per minute'
+    , plural: 'rotations per minute'
+    }
+  , to_anchor: 1/60
+  }
+, "deg/s": {
+    name: {
+      singular: 'degree per second'
+    , plural: 'degrees per second'
+    }
+  , to_anchor: 1/360
+  }
+, "rad/s": {
+    name: {
+      singular: 'radian per second'
+    , plural: 'radians per second'
+    }
+  , to_anchor: 1/(Math.PI * 2)
+  }
+};
+
+
+module.exports = {
+  metric: frequency
+, _anchors: {
+    frequency: {
+      unit: 'hz'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/illuminance.js

@@ -0,0 +1,37 @@
+var metric,
+imperial;
+
+metric = {
+  'lx': {
+    name: {
+      singular: 'Lux',
+      plural: 'Lux'
+    },
+    to_anchor: 1
+  }
+};
+
+imperial = {
+  'ft-cd': {
+    name: {
+      singular: 'Foot-candle',
+      plural: 'Foot-candles'
+    },
+    to_anchor: 1
+  }
+};
+
+module.exports = {
+  metric: metric,
+  imperial: imperial,
+  _anchors: {
+    metric: {
+      unit: 'lx',
+      ratio: 1/10.76391
+    },
+    imperial: {
+      unit: 'ft-cd',      
+	  ratio: 10.76391
+    }
+  }
+};

src/convert/definitions/length.js

@@ -0,0 +1,86 @@
+var metric,
+imperial;
+
+metric = {
+  mm: {
+    name: {
+      singular: 'Millimeter',
+      plural: 'Millimeters'
+    },
+    to_anchor: 1/1000
+  },
+  cm: {
+    name: {
+      singular: 'Centimeter',
+      plural: 'Centimeters'
+    },
+    to_anchor: 1/100
+  },
+  m: {
+    name: {
+      singular: 'Meter',
+      plural: 'Meters'
+    },
+    to_anchor: 1
+  },
+  km: {
+    name: {
+      singular: 'Kilometer',
+      plural: 'Kilometers'
+    },
+    to_anchor: 1000
+  }
+};
+
+imperial = {
+  'in': {
+    name: {
+      singular: 'Inch',
+      plural: 'Inches'
+    },
+    to_anchor: 1/12
+  },
+  yd: {
+    name: {
+      singular: 'Yard',
+      plural: 'Yards'
+    },
+    to_anchor: 3
+  },
+  'ft-us': {
+    name: {
+      singular: 'US Survey Foot',
+      plural: 'US Survey Feet'
+    },
+    to_anchor: 1.000002
+  },
+  ft: {
+    name: {
+      singular: 'Foot',
+      plural: 'Feet'
+    },
+    to_anchor: 1
+  },
+  mi: {
+    name: {
+      singular: 'Mile',
+      plural: 'Miles'
+    },
+    to_anchor: 5280
+  }
+};
+
+module.exports = {
+  metric: metric,
+  imperial: imperial,
+  _anchors: {
+    metric: {
+      unit: 'm',
+      ratio: 3.28084
+    },
+    imperial: {
+      unit: 'ft',
+      ratio: 1/3.28084
+    }
+  }
+};

src/convert/definitions/mass.js

@@ -0,0 +1,78 @@
+var metric
+  , imperial;
+
+metric = {
+  mcg: {
+    name: {
+      singular: 'Microgram'
+    , plural: 'Micrograms'
+    }
+  , to_anchor: 1/1000000
+  }
+, mg: {
+    name: {
+      singular: 'Milligram'
+    , plural: 'Milligrams'
+    }
+  , to_anchor: 1/1000
+  }
+, g: {
+    name: {
+      singular: 'Gram'
+    , plural: 'Grams'
+    }
+  , to_anchor: 1
+  }
+, kg: {
+    name: {
+      singular: 'Kilogram'
+    , plural: 'Kilograms'
+    }
+  , to_anchor: 1000
+}
+, mt: {
+    name: {
+      singular: 'Metric Tonne'
+    , plural: 'Metric Tonnes'
+    }
+  , to_anchor: 1000000
+  }
+};
+
+imperial = {
+  oz: {
+    name: {
+      singular: 'Ounce'
+    , plural: 'Ounces'
+    }
+  , to_anchor: 1/16
+  }
+, lb: {
+    name: {
+      singular: 'Pound'
+    , plural: 'Pounds'
+    }
+  , to_anchor: 1
+}, t: {
+  name: {
+    singular: 'Ton',
+    plural: 'Tons',
+  },
+    to_anchor: 2000,
+  },
+};
+
+module.exports = {
+  metric: metric
+, imperial: imperial
+, _anchors: {
+    metric: {
+      unit: 'g'
+    , ratio: 1/453.592
+    }
+  , imperial: {
+      unit: 'lb'
+    , ratio: 453.592
+    }
+  }
+};

src/convert/definitions/pace.js

@@ -0,0 +1,51 @@
+var metric
+  , imperial;
+
+metric = {
+  'min/km': {
+    name: {
+      singular: 'Minute per kilometre'
+    , plural: 'Minutes per kilometre'
+    }
+  , to_anchor: 0.06
+  }
+  ,'s/m': {
+    name: {
+      singular: 'Second per metre'
+    , plural: 'Seconds per metre'
+    }
+  , to_anchor: 1
+  }
+}
+
+imperial = {
+    'min/mi': {
+      name: {
+        singular: 'Minute per mile'
+      , plural: 'Minutes per mile'
+      }
+    , to_anchor: 0.0113636
+   }
+   , 's/ft': {
+      name: {
+        singular: 'Second per foot'
+      , plural: 'Seconds per foot'
+      }
+    , to_anchor: 1
+   }
+};
+
+module.exports = {
+  metric: metric
+, imperial: imperial
+, _anchors: {
+    metric: {
+      unit: 's/m'
+    , ratio: 0.3048
+    }
+  , imperial: {
+      unit: 's/ft'
+    , ratio: 1/0.3048
+    }
+  }
+};

src/convert/definitions/partsPer.js

@@ -0,0 +1,44 @@
+var metric
+  , imperial;
+
+metric = {
+  ppm: {
+    name: {
+      singular: 'Part-per Million'
+      , plural: 'Parts-per Million'
+    }
+    , to_anchor: 1
+  }
+  , ppb: {
+    name: {
+      singular: 'Part-per Billion'
+      , plural: 'Parts-per Billion'
+    }
+    , to_anchor: .001
+  }
+  , ppt: {
+    name: {
+      singular: 'Part-per Trillion'
+      , plural: 'Parts-per Trillion'
+    }
+    , to_anchor: .000001
+  }
+  , ppq: {
+    name: {
+      singular: 'Part-per Quadrillion'
+      , plural: 'Parts-per Quadrillion'
+    }
+    , to_anchor: .000000001
+  }
+};
+
+module.exports = {
+  metric: metric
+  , imperial: {}
+  , _anchors: {
+    metric: {
+      unit: 'ppm'
+      , ratio: .000001
+    }
+  }
+};

src/convert/definitions/power.js

@@ -0,0 +1,49 @@
+var power;
+
+power = {
+  W: {
+    name: {
+      singular: 'Watt'
+    , plural: 'Watts'
+    }
+  , to_anchor: 1
+  }
+, mW: {
+    name: {
+      singular: 'Milliwatt'
+      , plural: 'Milliwatts'
+    }
+    , to_anchor: .001
+  }
+, kW: {
+    name: {
+      singular: 'Kilowatt'
+    , plural: 'Kilowatts'
+    }
+  , to_anchor: 1000
+  }
+, MW: {
+    name: {
+      singular: 'Megawatt'
+    , plural: 'Megawatts'
+    }
+  , to_anchor: 1000000
+  }
+, GW: {
+    name: {
+      singular: 'Gigawatt'
+    , plural: 'Gigawatts'
+    }
+  , to_anchor: 1000000000
+  }
+};
+
+module.exports = {
+  metric: power
+, _anchors: {
+    metric: {
+      unit: 'W'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/pressure.js

@@ -0,0 +1,86 @@
+var metric
+  , imperial;
+
+metric = {
+  Pa: {
+    name: {
+      singular: 'pascal'
+    , plural: 'pascals'
+    }
+  , to_anchor: 1/1000
+  }
+, kPa: {
+    name: {
+      singular: 'kilopascal'
+    , plural: 'kilopascals'
+    }
+  , to_anchor: 1
+  }
+, MPa: {
+    name: {
+      singular: 'megapascal'
+    , plural: 'megapascals'
+    }
+  , to_anchor: 1000
+  }
+, hPa: {
+    name: {
+      singular: 'hectopascal'
+    , plural: 'hectopascals'
+    }
+  , to_anchor: 1/10
+  }
+, bar: {
+    name: {
+      singular: 'bar'
+    , plural: 'bar'
+    }
+  , to_anchor: 100
+  }
+  , mbar: {
+    name: {
+      singular: 'mbar'
+    , plural: 'mbar'
+    }
+  , to_anchor: 1/10
+  }
+, torr: {
+    name: {
+      singular: 'torr'
+    , plural: 'torr'
+    }
+  , to_anchor: 101325/760000
+  }
+};
+
+imperial = {
+  psi: {
+    name: {
+      singular: 'pound per square inch'
+    , plural: 'pounds per square inch'
+    }
+  , to_anchor: 1/1000
+  }
+, ksi: {
+    name: {
+      singular: 'kilopound per square inch'
+    , plural: 'kilopound per square inch'
+    }
+  , to_anchor: 1
+  }
+};
+
+module.exports = {
+  metric: metric
+, imperial: imperial
+, _anchors: {
+    metric: {
+      unit: 'kPa'
+    , ratio: 0.00014503768078
+    }
+  , imperial: {
+      unit: 'psi'
+    , ratio: 1/0.00014503768078
+    }
+  }
+};

src/convert/definitions/reactiveEnergy.js

@@ -0,0 +1,49 @@
+var reactiveEnergy;
+
+reactiveEnergy = {
+  VARh: {
+    name: {
+      singular: 'Volt-Ampere Reactive Hour'
+    , plural: 'Volt-Amperes Reactive Hour'
+    }
+  , to_anchor: 1
+  }
+, mVARh: {
+    name: {
+      singular: 'Millivolt-Ampere Reactive Hour'
+      , plural: 'Millivolt-Amperes Reactive Hour'
+    }
+    , to_anchor: .001
+  }
+, kVARh: {
+    name: {
+      singular: 'Kilovolt-Ampere Reactive Hour'
+    , plural: 'Kilovolt-Amperes Reactive Hour'
+    }
+  , to_anchor: 1000
+  }
+, MVARh: {
+    name: {
+      singular: 'Megavolt-Ampere Reactive Hour'
+    , plural: 'Megavolt-Amperes Reactive Hour'
+    }
+  , to_anchor: 1000000
+  }
+, GVARh: {
+    name: {
+      singular: 'Gigavolt-Ampere Reactive Hour'
+    , plural: 'Gigavolt-Amperes Reactive Hour'
+    }
+  , to_anchor: 1000000000
+  }
+};
+
+module.exports = {
+  metric: reactiveEnergy
+, _anchors: {
+    metric: {
+      unit: 'VARh'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/reactivePower.js

@@ -0,0 +1,49 @@
+var reactivePower;
+
+reactivePower = {
+  VAR: {
+    name: {
+      singular: 'Volt-Ampere Reactive'
+    , plural: 'Volt-Amperes Reactive'
+    }
+  , to_anchor: 1
+  }
+, mVAR: {
+    name: {
+      singular: 'Millivolt-Ampere Reactive'
+      , plural: 'Millivolt-Amperes Reactive'
+    }
+    , to_anchor: .001
+  }
+, kVAR: {
+    name: {
+      singular: 'Kilovolt-Ampere Reactive'
+    , plural: 'Kilovolt-Amperes Reactive'
+    }
+  , to_anchor: 1000
+  }
+, MVAR: {
+    name: {
+      singular: 'Megavolt-Ampere Reactive'
+    , plural: 'Megavolt-Amperes Reactive'
+    }
+  , to_anchor: 1000000
+  }
+, GVAR: {
+    name: {
+      singular: 'Gigavolt-Ampere Reactive'
+    , plural: 'Gigavolt-Amperes Reactive'
+    }
+  , to_anchor: 1000000000
+  }
+};
+
+module.exports = {
+  metric: reactivePower
+, _anchors: {
+    metric: {
+      unit: 'VAR'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/speed.js

@@ -0,0 +1,58 @@
+var metric
+  , imperial;
+
+metric = {
+  'm/s': {
+    name: {
+      singular: 'Metre per second'
+    , plural: 'Metres per second'
+    }
+  , to_anchor: 3.6
+  }
+, 'km/h': {
+    name: {
+      singular: 'Kilometre per hour'
+    , plural: 'Kilometres per hour'
+    }
+  , to_anchor: 1
+  }
+}
+
+  imperial = {
+    'm/h': {
+      name: {
+        singular: 'Mile per hour'
+      , plural: 'Miles per hour'
+      }
+    , to_anchor: 1
+    }
+  , knot: {
+      name: {
+        singular: 'Knot'
+      , plural: 'Knots'
+      }
+    , to_anchor: 1.150779
+    }
+  , 'ft/s': {
+      name: {
+        singular: 'Foot per second'
+      , plural: 'Feet per second'
+      }
+    , to_anchor: 0.681818
+      }
+};
+
+module.exports = {
+  metric: metric
+, imperial: imperial
+, _anchors: {
+    metric: {
+      unit: 'km/h'
+    , ratio: 1/1.609344
+    }
+  , imperial: {
+      unit: 'm/h'
+    , ratio: 1.609344
+    }
+  }
+};

src/convert/definitions/temperature.js

@@ -0,0 +1,55 @@
+var metric
+  , imperial;
+
+metric = {
+  C: {
+    name: {
+      singular: 'degree Celsius'
+    , plural: 'degrees Celsius'
+    }
+  , to_anchor: 1
+  , anchor_shift: 0
+  },
+  K: {
+    name: {
+      singular: 'degree Kelvin'
+    , plural: 'degrees Kelvin'
+    }
+  , to_anchor: 1
+  , anchor_shift: 273.15
+  }
+};
+
+imperial = {
+  F: {
+    name: {
+      singular: 'degree Fahrenheit'
+    , plural: 'degrees Fahrenheit'
+    }
+  , to_anchor: 1
+  },
+  R: {
+    name: {
+      singular: 'degree Rankine'
+    , plural: 'degrees Rankine'
+    }
+  , to_anchor: 1
+  , anchor_shift: 459.67
+  }
+};
+
+module.exports = {
+  metric: metric
+, imperial: imperial
+, _anchors: {
+    metric: {
+      unit: 'C'
+    , transform: function (C) { return C / (5/9) + 32 }
+    }
+  , imperial: {
+      unit: 'F'
+    , transform: function (F) { return (F - 32) * (5/9) }
+    }
+  }
+};
+

src/convert/definitions/time.js

@@ -0,0 +1,86 @@
+var time;
+var daysInYear = 365.25;
+
+time = {
+  ns: {
+    name: {
+      singular: 'Nanosecond'
+    , plural: 'Nanoseconds'
+    }
+  , to_anchor: 1/1000000000
+  }
+, mu: {
+    name: {
+      singular: 'Microsecond'
+    , plural: 'Microseconds'
+    }
+  , to_anchor: 1/1000000
+  }
+, ms: {
+    name: {
+      singular: 'Millisecond'
+    , plural: 'Milliseconds'
+    }
+  , to_anchor: 1/1000
+  }
+, s: {
+    name: {
+      singular: 'Second'
+    , plural: 'Seconds'
+    }
+  , to_anchor: 1
+  }
+, min: {
+    name: {
+      singular: 'Minute'
+    , plural: 'Minutes'
+    }
+  , to_anchor: 60
+  }
+, h: {
+    name: {
+      singular: 'Hour'
+    , plural: 'Hours'
+    }
+  , to_anchor: 60 * 60 
+  }
+, d: {
+    name: {
+      singular: 'Day'
+    , plural: 'Days'
+    }
+  , to_anchor: 60 * 60 * 24
+  }
+, week: {
+    name: {
+      singular: 'Week'
+    , plural: 'Weeks'
+    }
+  , to_anchor: 60 * 60 * 24 * 7
+  }
+, month: {
+    name: {
+      singular: 'Month'
+    , plural: 'Months'
+    }
+  , to_anchor: 60 * 60 * 24 * daysInYear / 12
+  }
+, year: {
+    name: {
+      singular: 'Year'
+    , plural: 'Years'
+    }
+  , to_anchor: 60 * 60 * 24 * daysInYear
+  }
+};
+
+
+module.exports = {
+  metric: time 
+, _anchors: {
+    metric: {
+      unit: 's'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/voltage.js

@@ -0,0 +1,35 @@
+var voltage;
+
+voltage = {
+  V: {
+    name: {
+      singular: 'Volt'
+    , plural: 'Volts'
+    }
+  , to_anchor: 1
+  }
+, mV: {
+    name: {
+      singular: 'Millivolt'
+      , plural: 'Millivolts'
+    }
+    , to_anchor: .001
+  }
+, kV: {
+    name: {
+      singular: 'Kilovolt'
+    , plural: 'Kilovolts'
+    }
+  , to_anchor: 1000
+  }
+};
+
+module.exports = {
+  metric: voltage
+, _anchors: {
+    metric: {
+      unit: 'V'
+    , ratio: 1
+    }
+  }
+};

src/convert/definitions/volume.js

@@ -0,0 +1,200 @@
+var metric
+  , imperial;
+
+metric = {
+  mm3: {
+      name: {
+        singular: 'Cubic Millimeter'
+      , plural: 'Cubic Millimeters'
+      }
+    , to_anchor: 1/1000000
+  }
+, cm3: {
+    name: {
+      singular: 'Cubic Centimeter'
+    , plural: 'Cubic Centimeters'
+    }
+  , to_anchor: 1/1000
+  }
+, ml: {
+    name: {
+      singular: 'Millilitre'
+    , plural: 'Millilitres'
+    }
+  , to_anchor: 1/1000
+  }
+, cl: {
+    name: {
+      singular: 'Centilitre'
+    , plural: 'Centilitres'
+    }
+  , to_anchor: 1/100
+  }
+, dl: {
+    name: {
+      singular: 'Decilitre'
+    , plural: 'Decilitres'
+    }
+  , to_anchor: 1/10
+  }
+, l: {
+    name: {
+      singular: 'Litre'
+    , plural: 'Litres'
+    }
+  , to_anchor: 1
+  }
+, kl: {
+    name: {
+      singular: 'Kilolitre'
+    , plural: 'Kilolitres'
+    }
+  , to_anchor: 1000
+  }
+, m3: {
+    name: {
+      singular: 'Cubic meter'
+    , plural: 'Cubic meters'
+    }
+  , to_anchor: 1000
+  }
+, km3: {
+    name: {
+      singular: 'Cubic kilometer'
+    , plural: 'Cubic kilometers'
+    }
+  , to_anchor: 1000000000000
+  }
+
+// Swedish units
+, krm: {
+  name: {
+    singular: 'Matsked'
+    , plural: 'Matskedar'
+  }
+  , to_anchor: 1/1000
+}
+, tsk: {
+    name: {
+      singular: 'Tesked'
+    , plural: 'Teskedar'
+    }
+  , to_anchor: 5/1000
+  }
+, msk: {
+    name: {
+      singular: 'Matsked'
+      , plural: 'Matskedar'
+    }
+    , to_anchor: 15/1000
+  }
+, kkp: {
+    name: {
+      singular: 'Kaffekopp'
+      , plural: 'Kaffekoppar'
+    }
+    , to_anchor: 150/1000
+  }
+, glas: {
+    name: {
+      singular: 'Glas'
+      , plural: 'Glas'
+    }
+    , to_anchor: 200/1000
+  }
+, kanna: {
+    name: {
+      singular: 'Kanna'
+    , plural: 'Kannor'
+    }
+  , to_anchor: 2.617
+  }
+};
+
+imperial = {
+  tsp: {
+    name: {
+      singular: 'Teaspoon'
+    , plural: 'Teaspoons'
+    }
+  , to_anchor: 1/6
+  }
+, Tbs: {
+    name: {
+      singular: 'Tablespoon'
+    , plural: 'Tablespoons'
+    }
+  , to_anchor: 1/2
+  }
+, in3: {
+    name: {
+      singular: 'Cubic inch'
+    , plural: 'Cubic inches'
+    }
+  , to_anchor: 0.55411
+  }
+, 'fl-oz': {
+    name: {
+      singular: 'Fluid Ounce'
+    , plural: 'Fluid Ounces'
+    }
+  , to_anchor: 1
+  }
+, cup: {
+    name: {
+      singular: 'Cup'
+    , plural: 'Cups'
+    }
+  , to_anchor: 8
+  }
+, pnt: {
+    name: {
+      singular: 'Pint'
+    , plural: 'Pints'
+    }
+  , to_anchor: 16
+  }
+, qt: {
+    name: {
+      singular: 'Quart'
+    , plural: 'Quarts'
+    }
+  , to_anchor: 32
+  }
+, gal: {
+    name: {
+      singular: 'Gallon'
+    , plural: 'Gallons'
+    }
+  , to_anchor: 128
+  }
+, ft3: {
+    name: {
+      singular: 'Cubic foot'
+    , plural: 'Cubic feet'
+    }
+  , to_anchor: 957.506
+  }
+, yd3: {
+    name: {
+      singular: 'Cubic yard'
+    , plural: 'Cubic yards'
+    }
+  , to_anchor: 25852.7
+  }
+};
+
+module.exports = {
+  metric: metric
+, imperial: imperial
+, _anchors: {
+    metric: {
+      unit: 'l'
+    , ratio: 33.8140226
+    }
+  , imperial: {
+      unit: 'fl-oz'
+    , ratio: 1/33.8140226
+    }
+  }
+};

src/convert/definitions/volumeFlowRate.js

@@ -0,0 +1,282 @@
+var metric
+  , imperial;
+
+metric = {
+  'mm3/s': {
+      name: {
+        singular: 'Cubic Millimeter per second'
+      , plural: 'Cubic Millimeters per second'
+      }
+    , to_anchor: 1/1000000
+  }
+, 'cm3/s': {
+    name: {
+      singular: 'Cubic Centimeter per second'
+    , plural: 'Cubic Centimeters per second'
+    }
+  , to_anchor: 1/1000
+  }
+, 'ml/s': {
+    name: {
+      singular: 'Millilitre per second'
+    , plural: 'Millilitres per second'
+    }
+  , to_anchor: 1/1000
+  }
+, 'cl/s': {
+    name: {
+      singular: 'Centilitre per second'
+    , plural: 'Centilitres per second'
+    }
+  , to_anchor: 1/100
+  }
+, 'dl/s': {
+    name: {
+      singular: 'Decilitre per second'
+    , plural: 'Decilitres per second'
+    }
+  , to_anchor: 1/10
+  }
+, 'l/s': {
+    name: {
+      singular: 'Litre per second'
+    , plural: 'Litres per second'
+    }
+  , to_anchor: 1
+  }
+, 'l/min': {
+    name: {
+      singular: 'Litre per minute'
+    , plural: 'Litres per minute'
+    }
+  , to_anchor: 1/60
+  }
+, 'l/h': {
+    name: {
+      singular: 'Litre per hour'
+    , plural: 'Litres per hour'
+    }
+  , to_anchor: 1/3600
+  }
+, 'kl/s': {
+    name: {
+      singular: 'Kilolitre per second'
+    , plural: 'Kilolitres per second'
+    }
+  , to_anchor: 1000
+  }
+, 'kl/min': {
+    name: {
+      singular: 'Kilolitre per minute'
+    , plural: 'Kilolitres per minute'
+    }
+  , to_anchor: 50/3
+  }
+, 'kl/h': {
+    name: {
+      singular: 'Kilolitre per hour'
+    , plural: 'Kilolitres per hour'
+    }
+  , to_anchor: 5/18
+  }
+, 'm3/s': {
+    name: {
+      singular: 'Cubic meter per second'
+    , plural: 'Cubic meters per second'
+    }
+  , to_anchor: 1000
+  }
+, 'm3/min': {
+    name: {
+      singular: 'Cubic meter per minute'
+    , plural: 'Cubic meters per minute'
+    }
+  , to_anchor: 50/3
+  }
+, 'm3/h': {
+    name: {
+      singular: 'Cubic meter per hour'
+    , plural: 'Cubic meters per hour'
+    }
+  , to_anchor: 5/18
+  }
+, 'km3/s': {
+    name: {
+      singular: 'Cubic kilometer per second'
+    , plural: 'Cubic kilometers per second'
+    }
+  , to_anchor: 1000000000000
+  }
+};
+
+imperial = {
+  'tsp/s': {
+    name: {
+      singular: 'Teaspoon per second'
+    , plural: 'Teaspoons per second'
+    }
+  , to_anchor: 1/6
+  }
+, 'Tbs/s': {
+    name: {
+      singular: 'Tablespoon per second'
+    , plural: 'Tablespoons per second'
+    }
+  , to_anchor: 1/2
+  }
+, 'in3/s': {
+    name: {
+      singular: 'Cubic inch per second'
+    , plural: 'Cubic inches per second'
+    }
+  , to_anchor: 0.55411
+  }
+, 'in3/min': {
+    name: {
+      singular: 'Cubic inch per minute'
+    , plural: 'Cubic inches per minute'
+    }
+  , to_anchor: 0.55411/60
+  }
+, 'in3/h': {
+    name: {
+      singular: 'Cubic inch per hour'
+    , plural: 'Cubic inches per hour'
+    }
+  , to_anchor: 0.55411/3600
+  }
+, 'fl-oz/s': {
+    name: {
+      singular: 'Fluid Ounce per second'
+    , plural: 'Fluid Ounces per second'
+    }
+  , to_anchor: 1
+  }
+, 'fl-oz/min': {
+    name: {
+      singular: 'Fluid Ounce per minute'
+    , plural: 'Fluid Ounces per minute'
+    }
+  , to_anchor: 1/60
+  }
+, 'fl-oz/h': {
+    name: {
+      singular: 'Fluid Ounce per hour'
+    , plural: 'Fluid Ounces per hour'
+    }
+  , to_anchor: 1/3600
+  }
+, 'cup/s': {
+    name: {
+      singular: 'Cup per second'
+    , plural: 'Cups per second'
+    }
+  , to_anchor: 8
+  }
+, 'pnt/s': {
+    name: {
+      singular: 'Pint per second'
+    , plural: 'Pints per second'
+    }
+  , to_anchor: 16
+  }
+, 'pnt/min': {
+    name: {
+      singular: 'Pint per minute'
+    , plural: 'Pints per minute'
+    }
+  , to_anchor: 4/15
+  }
+, 'pnt/h': {
+    name: {
+      singular: 'Pint per hour'
+    , plural: 'Pints per hour'
+    }
+  , to_anchor: 1/225
+  }
+, 'qt/s': {
+    name: {
+      singular: 'Quart per second'
+    , plural: 'Quarts per second'
+    }
+  , to_anchor: 32
+  }
+, 'gal/s': {
+    name: {
+      singular: 'Gallon per second'
+    , plural: 'Gallons per second'
+    }
+  , to_anchor: 128
+  }
+, 'gal/min': {
+    name: {
+      singular: 'Gallon per minute'
+    , plural: 'Gallons per minute'
+    }
+  , to_anchor: 32/15
+  }
+, 'gal/h': {
+    name: {
+      singular: 'Gallon per hour'
+    , plural: 'Gallons per hour'
+    }
+  , to_anchor: 8/225
+  }
+, 'ft3/s': {
+    name: {
+      singular: 'Cubic foot per second'
+    , plural: 'Cubic feet per second'
+    }
+  , to_anchor: 957.506
+  }
+, 'ft3/min': {
+    name: {
+      singular: 'Cubic foot per minute'
+    , plural: 'Cubic feet per minute'
+    }
+  , to_anchor: 957.506/60
+  }
+, 'ft3/h': {
+    name: {
+      singular: 'Cubic foot per hour'
+    , plural: 'Cubic feet per hour'
+    }
+  , to_anchor: 957.506/3600
+  }
+, 'yd3/s': {
+    name: {
+      singular: 'Cubic yard per second'
+    , plural: 'Cubic yards per second'
+    }
+  , to_anchor: 25852.7
+  }
+, 'yd3/min': {
+    name: {
+      singular: 'Cubic yard per minute'
+    , plural: 'Cubic yards per minute'
+    }
+  , to_anchor: 25852.7/60
+  }
+, 'yd3/h': {
+    name: {
+      singular: 'Cubic yard per hour'
+    , plural: 'Cubic yards per hour'
+    }
+  , to_anchor: 25852.7/3600
+  }
+};
+
+module.exports = {
+  metric: metric
+, imperial: imperial
+, _anchors: {
+    metric: {
+      unit: 'l/s'
+    , ratio: 33.8140227
+    }
+  , imperial: {
+      unit: 'fl-oz/s'
+    , ratio: 1/33.8140227
+    }
+  }
+};

src/convert/fysics.js

@@ -0,0 +1,160 @@
+/*
+Copyright: 
+Year : (c) 2023 
+Author : Rene De Ren
+Contact details : zn375ix3@gmail.com 
+Location : The Netherlands
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files 
+(the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, 
+merge, publish, distribute, sublicense, and/or sell copies of the Software, 
+and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+The author shall be notified of any and all improvements or adaptations this software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+
+class Fysics{
+    
+    constructor(){ 
+
+        //gasses
+        this.air_density = 0; // weight of air
+        this.atm_pressure = 1.01325 ; //atm pressure at sea level
+        this.earth_gravity = 9.80665 ; // acceleration of standard gravity on earth in m/s2
+        this.water_molar_mass = 18.01528 // g/mol
+        this.num_moles_water = 6.022 * 1023; // number of moles in water
+        this.water_density =  997 ; // this.water_molar_mass * this.num_moles_water // water density in kg/m3; 
+        
+        //load converter
+        this.convert = require('./index');
+
+        // o2 solubility curve based on pressure and temp
+        this.o2Solubility = {
+            1:  // abs bar
+            { 
+                x:[0,5,10,15,20,25,30,35,40,45,50], // temp in degrees celcius
+                y:[14.6,12.8,11.3,10.1,9.1,8.3,7.6,7,6.5,6,5.6], // mg/l
+            },
+            2:  // abs bar
+            { 
+                x:[0,5,10,15,20,25,30,35,40,45,50], // temp in degrees celcius
+                y:[29.2,25.5,22.6,20.2,18.2,16.5,15.2,14,12.9,12,11.3], // mg/l
+            },
+            4:  // abs bar
+            { 
+                x:[0,5,10,15,20,25,30,35,40,45,50], // temp in degrees celcius
+                y:[58.4,51.1,45.1,40.3,36.4,33.1,30.3,27.9,25.9,24,22.7], // mg/l
+            },
+        }
+
+    }
+
+    /*-------------------               functions               -------------------*/ 
+    //use input to calculate air density in kg/m3 is valid up to 100 degrees
+    //pressure in bar RH in % and temp in degrees celcius
+    // Antoine Equation is,  Log P = A - B / ( T + C )
+    // D8 = temp , d7 = RH , pressure in mbar = d6
+    //=1.2923*(273.15/(273.15+temp))*(((pressure*100000)-0.3783*((((MACHT(10,(8.07-(1730.63/(233.43+temp)))))*1000/760)*RH)*100))/(1.01325*100000))
+    /*
+    calc_air_dens(pressure,RH,temp){
+
+        let air_density = 
+        1.2923 * 
+        ( 
+            273.15 / ( 273.15 + temp ) 
+        )
+        *
+        (
+            (
+                (
+                    pressure * 100000
+                ) 
+                - 0.3783 * 
+                ( 
+                    ( 
+                        ( 
+                            ( 
+                                Math.pow( 10, ( 8.07 - ( 1730.63 / ( 233.43 + temp) ) ) ) 
+                            )
+                            *1000/760
+                        )
+                        *RH
+                    )
+                    *100
+                ) 
+            ) 
+            / (this.atm_pressure * 100000 )
+        );
+
+        return air_density ;
+    }
+    */
+
+    calc_air_dens(pressure, RH, temp) {
+        const Rd = 287.05; // Specific gas constant for dry air in J/(kg·K)
+        const Rv = 461.495; // Specific gas constant for water vapor in J/(kg·K)
+        
+        // Convert temperature to Kelvin
+        const T = temp + 273.15;
+        
+        // Antoine constants for water vapor
+        const A = 8.07131;
+        const B = 1730.63;
+        const C = 233.426;
+        
+        // Calculate saturation vapor pressure (e_s) using the Antoine equation (in hPa)
+        const e_s = Math.pow(10, (A - (B / (C + temp))));
+        
+        // Actual vapor pressure (e) in hPa
+        const e = RH * e_s / 100;
+        
+        // Convert pressure to Pascals
+        const pressurePa = this.convert(pressure).from('mbar').to('Pa');
+        
+        // Partial pressure of dry air (Pa)
+        const p_d = pressurePa - (e * 100);
+        
+        // Air density (kg/m³)
+        const air_density = (p_d / (Rd * T)) + ((e * 100) / (Rv * T));
+        
+        return air_density;
+    }
+
+    //convert height to pressure ( density => kg/m3 , height => meter) output is in bar
+    heigth_to_pressure(density,height){
+
+        //calc pressure
+        let pressure = density * this.earth_gravity * height;
+        //convert Pa to bar
+        pressure = this.convert(pressure).from('Pa').to('mbar');
+
+        return pressure;
+    }
+
+    //input is in meters ! 
+    calc_volume(height,width,length){
+        let result = 0;
+        result = height * width * length;
+        return result ;
+    }
+
+
+}
+
+/*
+let fysics = new Fysics();
+console.log("converted pressure : " + fysics.heigth_to_pressure(fysics.water_density,10) + " mbar ");
+console.log( "air density : " +  fysics.calc_air_dens(1.012,0,0) + " kg / m3" );
+
+//*/
+
+module.exports = Fysics;

src/convert/index.js

@@ -0,0 +1,304 @@
+var convert
+  , keys = require('./lodash/lodash.keys')
+  , each = require('./lodash/lodash.foreach')
+  , measures = {
+      length: require('./definitions/length')
+    , area: require('./definitions/area')
+    , mass: require('./definitions/mass')
+    , volume: require('./definitions/volume')
+    , each: require('./definitions/each')
+    , temperature: require('./definitions/temperature')
+    , time: require('./definitions/time')
+    , digital: require('./definitions/digital')
+    , partsPer: require('./definitions/partsPer')
+    , speed: require('./definitions/speed')
+    , pace: require('./definitions/pace')
+    , pressure: require('./definitions/pressure')
+    , current: require('./definitions/current')
+    , voltage: require('./definitions/voltage')
+    , power: require('./definitions/power')
+    , reactivePower: require('./definitions/reactivePower')
+    , apparentPower: require('./definitions/apparentPower')
+    , energy: require('./definitions/energy')
+    , reactiveEnergy: require('./definitions/reactiveEnergy')
+    , volumeFlowRate: require('./definitions/volumeFlowRate')
+    , illuminance: require('./definitions/illuminance')
+    , frequency: require('./definitions/frequency')
+    , angle : require('./definitions/angle')
+    }
+  , Converter;
+
+Converter = function (numerator, denominator) {
+  if(denominator)
+    this.val = numerator / denominator;
+  else
+    this.val = numerator;
+};
+
+/**
+* Lets the converter know the source unit abbreviation
+*/
+Converter.prototype.from = function (from) {
+  if(this.destination)
+    throw new Error('.from must be called before .to');
+
+  this.origin = this.getUnit(from);
+
+  if(!this.origin) {
+    this.throwUnsupportedUnitError(from);
+  }
+
+  return this;
+};
+
+/**
+* Converts the unit and returns the value
+*/
+Converter.prototype.to = function (to) {
+  if(!this.origin)
+    throw new Error('.to must be called after .from');
+
+  this.destination = this.getUnit(to);
+
+  var result
+    , transform;
+
+  if(!this.destination) {
+    this.throwUnsupportedUnitError(to);
+  }
+
+  // Don't change the value if origin and destination are the same
+  if (this.origin.abbr === this.destination.abbr) {
+    return this.val;
+  }
+
+  // You can't go from liquid to mass, for example
+  if(this.destination.measure != this.origin.measure) {
+    throw new Error('Cannot convert incompatible measures of '
+      + this.destination.measure + ' and ' + this.origin.measure);
+  }
+
+  /**
+  * Convert from the source value to its anchor inside the system
+  */
+  result = this.val * this.origin.unit.to_anchor;
+
+  /**
+  * For some changes it's a simple shift (C to K)
+  * So we'll add it when convering into the unit (later)
+  * and subtract it when converting from the unit
+  */
+  if (this.origin.unit.anchor_shift) {
+    result -= this.origin.unit.anchor_shift
+  }
+
+  /**
+  * Convert from one system to another through the anchor ratio. Some conversions
+  * aren't ratio based or require more than a simple shift. We can provide a custom
+  * transform here to provide the direct result
+  */
+  if(this.origin.system != this.destination.system) {
+    transform = measures[this.origin.measure]._anchors[this.origin.system].transform;
+    if (typeof transform === 'function') {
+      result = transform(result)
+    }
+    else {
+      result *= measures[this.origin.measure]._anchors[this.origin.system].ratio;
+    }
+  }
+
+  /**
+  * This shift has to be done after the system conversion business
+  */
+  if (this.destination.unit.anchor_shift) {
+    result += this.destination.unit.anchor_shift;
+  }
+
+  /**
+  * Convert to another unit inside the destination system
+  */
+  return result / this.destination.unit.to_anchor;
+};
+
+/**
+* Converts the unit to the best available unit.
+*/
+Converter.prototype.toBest = function(options) {
+  if(!this.origin)
+    throw new Error('.toBest must be called after .from');
+
+  var options = Object.assign({
+    exclude: [],
+    cutOffNumber: 1,
+  }, options)
+
+  var best;
+  /**
+    Looks through every possibility for the 'best' available unit.
+    i.e. Where the value has the fewest numbers before the decimal point,
+    but is still higher than 1.
+  */
+  each(this.possibilities(), function(possibility) {
+    var unit = this.describe(possibility);
+    var isIncluded = options.exclude.indexOf(possibility) === -1;
+
+    if (isIncluded && unit.system === this.origin.system) {
+      var result = this.to(possibility);
+      if (!best || (result >= options.cutOffNumber && result < best.val)) {
+        best = {
+          val: result,
+          unit: possibility,
+          singular: unit.singular,
+          plural: unit.plural
+        };
+      }
+    }
+  }.bind(this));
+
+  return best;
+}
+
+/**
+* Finds the unit
+*/
+Converter.prototype.getUnit = function (abbr) {
+  var found;
+
+  each(measures, function (systems, measure) {
+    each(systems, function (units, system) {
+      if(system == '_anchors')
+        return false;
+
+      each(units, function (unit, testAbbr) {
+        if(testAbbr == abbr) {
+          found = {
+            abbr: abbr
+          , measure: measure
+          , system: system
+          , unit: unit
+          };
+          return false;
+        }
+      });
+
+      if(found)
+        return false;
+    });
+
+    if(found)
+      return false;
+  });
+
+  return found;
+};
+
+var describe = function(resp) {
+  return {
+    abbr: resp.abbr
+  , measure: resp.measure
+  , system: resp.system
+  , singular: resp.unit.name.singular
+  , plural: resp.unit.name.plural
+  };
+}
+
+/**
+* An alias for getUnit
+*/
+Converter.prototype.describe = function (abbr) {
+  var resp = Converter.prototype.getUnit(abbr);
+  var desc = null;
+
+  try {
+    desc = describe(resp);
+  } catch(err) {
+    this.throwUnsupportedUnitError(abbr);
+  }
+
+  return desc;
+};
+
+/**
+* Detailed list of all supported units
+*/
+Converter.prototype.list = function (measure) {
+  var list = [];
+
+  each(measures, function (systems, testMeasure) {
+    if(measure && measure !== testMeasure)
+      return;
+
+    each(systems, function (units, system) {
+      if(system == '_anchors')
+        return false;
+
+      each(units, function (unit, abbr) {
+        list = list.concat(describe({
+          abbr: abbr,
+          measure: testMeasure
+        , system: system
+        , unit: unit
+        }));
+      });
+    });
+  });
+
+  return list;
+};
+
+Converter.prototype.throwUnsupportedUnitError = function (what) {
+  var validUnits = [];
+
+  each(measures, function (systems, measure) {
+    each(systems, function (units, system) {
+      if(system == '_anchors')
+        return false;
+
+      validUnits = validUnits.concat(keys(units));
+    });
+  });
+
+  throw new Error('Unsupported unit ' + what + ', use one of: ' + validUnits.join(', '));
+}
+
+/**
+* Returns the abbreviated measures that the value can be
+* converted to.
+*/
+Converter.prototype.possibilities = function (measure) {
+  var possibilities = [];
+  if(!this.origin && !measure) {
+	  each(keys(measures), function (measure){
+		  each(measures[measure], function (units, system) {
+		    if(system == '_anchors')
+		      return false;
+
+		    possibilities = possibilities.concat(keys(units));
+		  });
+	  });
+  } else {
+	  measure = measure || this.origin.measure;
+	  each(measures[measure], function (units, system) {
+	    if(system == '_anchors')
+	      return false;
+
+	    possibilities = possibilities.concat(keys(units));
+	  });
+  }
+
+  return possibilities;
+};
+
+/**
+* Returns the abbreviated measures that the value can be
+* converted to.
+*/
+Converter.prototype.measures = function () {
+  return keys(measures);
+};
+
+convert = function (value) {
+  return new Converter(value);
+};
+
+module.exports = convert;

src/convert/lodash/lodash._basebind/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+Based on Underscore.js 1.5.2, copyright 2009-2013 Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/convert/lodash/lodash._basebind/README.md

@@ -0,0 +1,15 @@
+# lodash._basebind v2.3.0
+
+The internal [Lo-Dash](http://lodash.com/) function `baseBind` as a [Node.js](http://nodejs.org/) module generated by [lodash-cli](https://npmjs.org/package/lodash-cli).
+
+## Author
+
+| [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](https://twitter.com/jdalton "Follow @jdalton on Twitter") |
+|---|
+| [John-David Dalton](http://allyoucanleet.com/) |
+
+## Contributors
+
+| [![twitter/blainebublitz](http://gravatar.com/avatar/ac1c67fd906c9fecd823ce302283b4c1?s=70)](https://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [![twitter/kitcambridge](http://gravatar.com/avatar/6662a1d02f351b5ef2f8b4d815804661?s=70)](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|---|---|
+| [Blaine Bublitz](http://www.iceddev.com/) | [Kit Cambridge](http://kitcambridge.be/) | [Mathias Bynens](http://mathiasbynens.be/) |

src/convert/lodash/lodash._basebind/index.js

@@ -0,0 +1,58 @@
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+var baseCreate = require('./../lodash._basecreate'),
+    isObject = require('./../lodash.isobject'),
+    setBindData = require('./../lodash._setbinddata');
+
+/**
+ * Used for `Array` method references.
+ *
+ * Normally `Array.prototype` would suffice, however, using an array literal
+ * avoids issues in Narwhal.
+ */
+var arrayRef = [];
+
+/** Native method shortcuts */
+var push = arrayRef.push;
+
+/**
+ * The base implementation of `_.bind` that creates the bound function and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new bound function.
+ */
+function baseBind(bindData) {
+  var func = bindData[0],
+      partialArgs = bindData[2],
+      thisArg = bindData[4];
+
+  function bound() {
+    // `Function#bind` spec
+    // http://es5.github.io/#x15.3.4.5
+    if (partialArgs) {
+      var args = partialArgs.slice();
+      push.apply(args, arguments);
+    }
+    // mimic the constructor's `return` behavior
+    // http://es5.github.io/#x13.2.2
+    if (this instanceof bound) {
+      // ensure `new bound` is an instance of `func`
+      var thisBinding = baseCreate(func.prototype),
+          result = func.apply(thisBinding, args || arguments);
+      return isObject(result) ? result : thisBinding;
+    }
+    return func.apply(thisArg, args || arguments);
+  }
+  setBindData(bound, bindData);
+  return bound;
+}
+
+module.exports = baseBind;

src/convert/lodash/lodash._basebind/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "lodash._basebind",
+  "version": "2.3.0",
+  "description": "The internal Lo-Dash function `baseBind` as a Node.js module generated by lodash-cli.",
+  "homepage": "http://lodash.com/custom-builds",
+  "license": "MIT",
+  "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+  "contributors": [
+    "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+    "Blaine Bublitz <blaine@iceddev.com> (http://www.iceddev.com/)",
+    "Kit Cambridge <github@kitcambridge.be> (http://kitcambridge.be/)",
+    "Mathias Bynens <mathias@qiwi.be> (http://mathiasbynens.be/)"
+  ],
+  "bugs": "https://github.com/lodash/lodash-cli/issues",
+  "repository": { "type": "git", "url": "https://github.com/lodash/lodash-cli.git" },
+  "dependencies": {
+    "lodash._basecreate": "~2.3.0",
+    "lodash.isobject": "~2.3.0",
+    "lodash._setbinddata": "~2.3.0"
+  }
+}

src/convert/lodash/lodash._basecreate/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+Based on Underscore.js 1.5.2, copyright 2009-2013 Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/convert/lodash/lodash._basecreate/README.md

@@ -0,0 +1,15 @@
+# lodash._basecreate v2.3.0
+
+The internal [Lo-Dash](http://lodash.com/) function `baseCreate` as a [Node.js](http://nodejs.org/) module generated by [lodash-cli](https://npmjs.org/package/lodash-cli).
+
+## Author
+
+| [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](https://twitter.com/jdalton "Follow @jdalton on Twitter") |
+|---|
+| [John-David Dalton](http://allyoucanleet.com/) |
+
+## Contributors
+
+| [![twitter/blainebublitz](http://gravatar.com/avatar/ac1c67fd906c9fecd823ce302283b4c1?s=70)](https://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [![twitter/kitcambridge](http://gravatar.com/avatar/6662a1d02f351b5ef2f8b4d815804661?s=70)](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|---|---|
+| [Blaine Bublitz](http://www.iceddev.com/) | [Kit Cambridge](http://kitcambridge.be/) | [Mathias Bynens](http://mathiasbynens.be/) |

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

@@ -0,0 +1,42 @@
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+var isObject = require('./../lodash.isobject'),
+    noop = require('./../lodash.noop'),
+    reNative = require('./../lodash._renative');
+
+/* Native method shortcuts for methods with the same name as other `lodash` methods */
+var nativeCreate = reNative.test(nativeCreate = Object.create) && nativeCreate;
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} prototype The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+function baseCreate(prototype, properties) {
+  return isObject(prototype) ? nativeCreate(prototype) : {};
+}
+// fallback for browsers without `Object.create`
+if (!nativeCreate) {
+  baseCreate = (function() {
+    function Object() {}
+    return function(prototype) {
+      if (isObject(prototype)) {
+        Object.prototype = prototype;
+        var result = new Object;
+        Object.prototype = null;
+      }
+      return result || global.Object();
+    };
+  }());
+}
+
+module.exports = baseCreate;

src/convert/lodash/lodash._basecreate/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "lodash._basecreate",
+  "version": "2.3.0",
+  "description": "The internal Lo-Dash function `baseCreate` as a Node.js module generated by lodash-cli.",
+  "homepage": "http://lodash.com/custom-builds",
+  "license": "MIT",
+  "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+  "contributors": [
+    "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+    "Blaine Bublitz <blaine@iceddev.com> (http://www.iceddev.com/)",
+    "Kit Cambridge <github@kitcambridge.be> (http://kitcambridge.be/)",
+    "Mathias Bynens <mathias@qiwi.be> (http://mathiasbynens.be/)"
+  ],
+  "bugs": "https://github.com/lodash/lodash-cli/issues",
+  "repository": { "type": "git", "url": "https://github.com/lodash/lodash-cli.git" },
+  "dependencies": {
+    "lodash.isobject": "~2.3.0",
+    "lodash.noop": "~2.3.0",
+    "lodash._renative": "~2.3.0"
+  }
+}

src/convert/lodash/lodash._basecreatecallback/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+Based on Underscore.js 1.5.2, copyright 2009-2013 Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/convert/lodash/lodash._basecreatecallback/README.md

@@ -0,0 +1,15 @@
+# lodash._basecreatecallback v2.3.0
+
+The internal [Lo-Dash](http://lodash.com/) function `baseCreateCallback` as a [Node.js](http://nodejs.org/) module generated by [lodash-cli](https://npmjs.org/package/lodash-cli).
+
+## Author
+
+| [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](https://twitter.com/jdalton "Follow @jdalton on Twitter") |
+|---|
+| [John-David Dalton](http://allyoucanleet.com/) |
+
+## Contributors
+
+| [![twitter/blainebublitz](http://gravatar.com/avatar/ac1c67fd906c9fecd823ce302283b4c1?s=70)](https://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [![twitter/kitcambridge](http://gravatar.com/avatar/6662a1d02f351b5ef2f8b4d815804661?s=70)](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|---|---|
+| [Blaine Bublitz](http://www.iceddev.com/) | [Kit Cambridge](http://kitcambridge.be/) | [Mathias Bynens](http://mathiasbynens.be/) |

src/convert/lodash/lodash._basecreatecallback/index.js

@@ -0,0 +1,80 @@
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+var bind = require('./../lodash.bind'),
+    identity = require('./../lodash.identity'),
+    setBindData = require('./../lodash._setbinddata'),
+    support = require('./../lodash.support');
+
+/** Used to detected named functions */
+var reFuncName = /^\s*function[ \n\r\t]+\w/;
+
+/** Used to detect functions containing a `this` reference */
+var reThis = /\bthis\b/;
+
+/** Native method shortcuts */
+var fnToString = Function.prototype.toString;
+
+/**
+ * The base implementation of `_.createCallback` without support for creating
+ * "_.pluck" or "_.where" style callbacks.
+ *
+ * @private
+ * @param {*} [func=identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of the created callback.
+ * @param {number} [argCount] The number of arguments the callback accepts.
+ * @returns {Function} Returns a callback function.
+ */
+function baseCreateCallback(func, thisArg, argCount) {
+  if (typeof func != 'function') {
+    return identity;
+  }
+  // exit early for no `thisArg` or already bound by `Function#bind`
+  if (typeof thisArg == 'undefined' || !('prototype' in func)) {
+    return func;
+  }
+  var bindData = func.__bindData__;
+  if (typeof bindData == 'undefined') {
+    if (support.funcNames) {
+      bindData = !func.name;
+    }
+    bindData = bindData || !support.funcDecomp;
+    if (!bindData) {
+      var source = fnToString.call(func);
+      if (!support.funcNames) {
+        bindData = !reFuncName.test(source);
+      }
+      if (!bindData) {
+        // checks if `func` references the `this` keyword and stores the result
+        bindData = reThis.test(source);
+        setBindData(func, bindData);
+      }
+    }
+  }
+  // exit early if there are no `this` references or `func` is bound
+  if (bindData === false || (bindData !== true && bindData[1] & 1)) {
+    return func;
+  }
+  switch (argCount) {
+    case 1: return function(value) {
+      return func.call(thisArg, value);
+    };
+    case 2: return function(a, b) {
+      return func.call(thisArg, a, b);
+    };
+    case 3: return function(value, index, collection) {
+      return func.call(thisArg, value, index, collection);
+    };
+    case 4: return function(accumulator, value, index, collection) {
+      return func.call(thisArg, accumulator, value, index, collection);
+    };
+  }
+  return bind(func, thisArg);
+}
+
+module.exports = baseCreateCallback;

src/convert/lodash/lodash._basecreatecallback/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "lodash._basecreatecallback",
+  "version": "2.3.0",
+  "description": "The internal Lo-Dash function `baseCreateCallback` as a Node.js module generated by lodash-cli.",
+  "homepage": "http://lodash.com/custom-builds",
+  "license": "MIT",
+  "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+  "contributors": [
+    "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+    "Blaine Bublitz <blaine@iceddev.com> (http://www.iceddev.com/)",
+    "Kit Cambridge <github@kitcambridge.be> (http://kitcambridge.be/)",
+    "Mathias Bynens <mathias@qiwi.be> (http://mathiasbynens.be/)"
+  ],
+  "bugs": "https://github.com/lodash/lodash-cli/issues",
+  "repository": { "type": "git", "url": "https://github.com/lodash/lodash-cli.git" },
+  "dependencies": {
+    "lodash.bind": "~2.3.0",
+    "lodash.identity": "~2.3.0",
+    "lodash._setbinddata": "~2.3.0",
+    "lodash.support": "~2.3.0"
+  }
+}

src/convert/lodash/lodash._basecreatewrapper/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+Based on Underscore.js 1.5.2, copyright 2009-2013 Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/convert/lodash/lodash._basecreatewrapper/README.md

@@ -0,0 +1,15 @@
+# lodash._basecreatewrapper v2.3.0
+
+The internal [Lo-Dash](http://lodash.com/) function `baseCreateWrapper` as a [Node.js](http://nodejs.org/) module generated by [lodash-cli](https://npmjs.org/package/lodash-cli).
+
+## Author
+
+| [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](https://twitter.com/jdalton "Follow @jdalton on Twitter") |
+|---|
+| [John-David Dalton](http://allyoucanleet.com/) |
+
+## Contributors
+
+| [![twitter/blainebublitz](http://gravatar.com/avatar/ac1c67fd906c9fecd823ce302283b4c1?s=70)](https://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [![twitter/kitcambridge](http://gravatar.com/avatar/6662a1d02f351b5ef2f8b4d815804661?s=70)](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|---|---|
+| [Blaine Bublitz](http://www.iceddev.com/) | [Kit Cambridge](http://kitcambridge.be/) | [Mathias Bynens](http://mathiasbynens.be/) |

src/convert/lodash/lodash._basecreatewrapper/index.js

@@ -0,0 +1,78 @@
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+var baseCreate = require('./../lodash._basecreate'),
+    isObject = require('./../lodash.isobject'),
+    setBindData = require('./../lodash._setbinddata'),
+    slice = require('./../lodash._slice');
+
+/**
+ * Used for `Array` method references.
+ *
+ * Normally `Array.prototype` would suffice, however, using an array literal
+ * avoids issues in Narwhal.
+ */
+var arrayRef = [];
+
+/** Native method shortcuts */
+var push = arrayRef.push;
+
+/**
+ * The base implementation of `createWrapper` that creates the wrapper and
+ * sets its meta data.
+ *
+ * @private
+ * @param {Array} bindData The bind data array.
+ * @returns {Function} Returns the new function.
+ */
+function baseCreateWrapper(bindData) {
+  var func = bindData[0],
+      bitmask = bindData[1],
+      partialArgs = bindData[2],
+      partialRightArgs = bindData[3],
+      thisArg = bindData[4],
+      arity = bindData[5];
+
+  var isBind = bitmask & 1,
+      isBindKey = bitmask & 2,
+      isCurry = bitmask & 4,
+      isCurryBound = bitmask & 8,
+      key = func;
+
+  function bound() {
+    var thisBinding = isBind ? thisArg : this;
+    if (partialArgs) {
+      var args = partialArgs.slice();
+      push.apply(args, arguments);
+    }
+    if (partialRightArgs || isCurry) {
+      args || (args = slice(arguments));
+      if (partialRightArgs) {
+        push.apply(args, partialRightArgs);
+      }
+      if (isCurry && args.length < arity) {
+        bitmask |= 16 & ~32;
+        return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]);
+      }
+    }
+    args || (args = arguments);
+    if (isBindKey) {
+      func = thisBinding[key];
+    }
+    if (this instanceof bound) {
+      thisBinding = baseCreate(func.prototype);
+      var result = func.apply(thisBinding, args);
+      return isObject(result) ? result : thisBinding;
+    }
+    return func.apply(thisBinding, args);
+  }
+  setBindData(bound, bindData);
+  return bound;
+}
+
+module.exports = baseCreateWrapper;

src/convert/lodash/lodash._basecreatewrapper/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "lodash._basecreatewrapper",
+  "version": "2.3.0",
+  "description": "The internal Lo-Dash function `baseCreateWrapper` as a Node.js module generated by lodash-cli.",
+  "homepage": "http://lodash.com/custom-builds",
+  "license": "MIT",
+  "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+  "contributors": [
+    "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+    "Blaine Bublitz <blaine@iceddev.com> (http://www.iceddev.com/)",
+    "Kit Cambridge <github@kitcambridge.be> (http://kitcambridge.be/)",
+    "Mathias Bynens <mathias@qiwi.be> (http://mathiasbynens.be/)"
+  ],
+  "bugs": "https://github.com/lodash/lodash-cli/issues",
+  "repository": { "type": "git", "url": "https://github.com/lodash/lodash-cli.git" },
+  "dependencies": {
+    "lodash._basecreate": "~2.3.0",
+    "lodash.isobject": "~2.3.0",
+    "lodash._setbinddata": "~2.3.0",
+    "lodash._slice": "~2.3.0"
+  }
+}

src/convert/lodash/lodash._createwrapper/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+Based on Underscore.js 1.5.2, copyright 2009-2013 Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/convert/lodash/lodash._createwrapper/README.md

@@ -0,0 +1,15 @@
+# lodash._createwrapper v2.3.0
+
+The internal [Lo-Dash](http://lodash.com/) function `createWrapper` as a [Node.js](http://nodejs.org/) module generated by [lodash-cli](https://npmjs.org/package/lodash-cli).
+
+## Author
+
+| [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](https://twitter.com/jdalton "Follow @jdalton on Twitter") |
+|---|
+| [John-David Dalton](http://allyoucanleet.com/) |
+
+## Contributors
+
+| [![twitter/blainebublitz](http://gravatar.com/avatar/ac1c67fd906c9fecd823ce302283b4c1?s=70)](https://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [![twitter/kitcambridge](http://gravatar.com/avatar/6662a1d02f351b5ef2f8b4d815804661?s=70)](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|---|---|
+| [Blaine Bublitz](http://www.iceddev.com/) | [Kit Cambridge](http://kitcambridge.be/) | [Mathias Bynens](http://mathiasbynens.be/) |

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

@@ -0,0 +1,98 @@
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+var baseBind = require('./../lodash._basebind'),
+    baseCreateWrapper = require('./../lodash._basecreatewrapper'),
+    isFunction = require('./../lodash.isfunction');
+
+/**
+ * Used for `Array` method references.
+ *
+ * Normally `Array.prototype` would suffice, however, using an array literal
+ * avoids issues in Narwhal.
+ */
+var arrayRef = [];
+
+/** Native method shortcuts */
+var push = arrayRef.push;
+
+/**
+ * Creates a function that, when called, either curries or invokes `func`
+ * with an optional `this` binding and partially applied arguments.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to reference.
+ * @param {number} bitmask The bitmask of method flags to compose.
+ *  The bitmask may be composed of the following flags:
+ *  1 - `_.bind`
+ *  2 - `_.bindKey`
+ *  4 - `_.curry`
+ *  8 - `_.curry` (bound)
+ *  16 - `_.partial`
+ *  32 - `_.partialRight`
+ * @param {Array} [partialArgs] An array of arguments to prepend to those
+ *  provided to the new function.
+ * @param {Array} [partialRightArgs] An array of arguments to append to those
+ *  provided to the new function.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new function.
+ */
+function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
+  var isBind = bitmask & 1,
+      isBindKey = bitmask & 2,
+      isCurry = bitmask & 4,
+      isCurryBound = bitmask & 8,
+      isPartial = bitmask & 16,
+      isPartialRight = bitmask & 32;
+
+  if (!isBindKey && !isFunction(func)) {
+    throw new TypeError;
+  }
+  if (isPartial && !partialArgs.length) {
+    bitmask &= ~16;
+    isPartial = partialArgs = false;
+  }
+  if (isPartialRight && !partialRightArgs.length) {
+    bitmask &= ~32;
+    isPartialRight = partialRightArgs = false;
+  }
+  var bindData = func && func.__bindData__;
+  if (bindData && bindData !== true) {
+    bindData = bindData.slice();
+
+    // set `thisBinding` is not previously bound
+    if (isBind && !(bindData[1] & 1)) {
+      bindData[4] = thisArg;
+    }
+    // set if previously bound but not currently (subsequent curried functions)
+    if (!isBind && bindData[1] & 1) {
+      bitmask |= 8;
+    }
+    // set curried arity if not yet set
+    if (isCurry && !(bindData[1] & 4)) {
+      bindData[5] = arity;
+    }
+    // append partial left arguments
+    if (isPartial) {
+      push.apply(bindData[2] || (bindData[2] = []), partialArgs);
+    }
+    // append partial right arguments
+    if (isPartialRight) {
+      push.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
+    }
+    // merge flags
+    bindData[1] |= bitmask;
+    return createWrapper.apply(null, bindData);
+  }
+  // fast path for `_.bind`
+  var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper;
+  return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);
+}
+
+module.exports = createWrapper;

src/convert/lodash/lodash._createwrapper/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "lodash._createwrapper",
+  "version": "2.3.0",
+  "description": "The internal Lo-Dash function `createWrapper` as a Node.js module generated by lodash-cli.",
+  "homepage": "http://lodash.com/custom-builds",
+  "license": "MIT",
+  "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+  "contributors": [
+    "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+    "Blaine Bublitz <blaine@iceddev.com> (http://www.iceddev.com/)",
+    "Kit Cambridge <github@kitcambridge.be> (http://kitcambridge.be/)",
+    "Mathias Bynens <mathias@qiwi.be> (http://mathiasbynens.be/)"
+  ],
+  "bugs": "https://github.com/lodash/lodash-cli/issues",
+  "repository": { "type": "git", "url": "https://github.com/lodash/lodash-cli.git" },
+  "dependencies": {
+    "lodash._basebind": "~2.3.0",
+    "lodash._basecreatewrapper": "~2.3.0",
+    "lodash.isfunction": "~2.3.0"
+  }
+}

src/convert/lodash/lodash._objecttypes/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+Based on Underscore.js 1.5.2, copyright 2009-2013 Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/convert/lodash/lodash._objecttypes/README.md

@@ -0,0 +1,15 @@
+# lodash._objecttypes v2.3.0
+
+The internal [Lo-Dash](http://lodash.com/) variable `objectTypes` as a [Node.js](http://nodejs.org/) module generated by [lodash-cli](https://npmjs.org/package/lodash-cli).
+
+## Author
+
+| [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](https://twitter.com/jdalton "Follow @jdalton on Twitter") |
+|---|
+| [John-David Dalton](http://allyoucanleet.com/) |
+
+## Contributors
+
+| [![twitter/blainebublitz](http://gravatar.com/avatar/ac1c67fd906c9fecd823ce302283b4c1?s=70)](https://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [![twitter/kitcambridge](http://gravatar.com/avatar/6662a1d02f351b5ef2f8b4d815804661?s=70)](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|---|---|
+| [Blaine Bublitz](http://www.iceddev.com/) | [Kit Cambridge](http://kitcambridge.be/) | [Mathias Bynens](http://mathiasbynens.be/) |

src/convert/lodash/lodash._objecttypes/index.js

@@ -0,0 +1,20 @@
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+/** Used to determine if values are of the language type Object */
+var objectTypes = {
+  'boolean': false,
+  'function': true,
+  'object': true,
+  'number': false,
+  'string': false,
+  'undefined': false
+};
+
+module.exports = objectTypes;

src/convert/lodash/lodash._objecttypes/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "lodash._objecttypes",
+  "version": "2.3.0",
+  "description": "The internal Lo-Dash variable `objectTypes` as a Node.js module generated by lodash-cli.",
+  "homepage": "http://lodash.com/custom-builds",
+  "license": "MIT",
+  "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+  "contributors": [
+    "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+    "Blaine Bublitz <blaine@iceddev.com> (http://www.iceddev.com/)",
+    "Kit Cambridge <github@kitcambridge.be> (http://kitcambridge.be/)",
+    "Mathias Bynens <mathias@qiwi.be> (http://mathiasbynens.be/)"
+  ],
+  "bugs": "https://github.com/lodash/lodash-cli/issues",
+  "repository": { "type": "git", "url": "https://github.com/lodash/lodash-cli.git" }
+}

src/convert/lodash/lodash._renative/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+Based on Underscore.js 1.5.2, copyright 2009-2013 Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/convert/lodash/lodash._renative/README.md

@@ -0,0 +1,15 @@
+# lodash._renative v2.3.0
+
+The internal [Lo-Dash](http://lodash.com/) variable `reNative` as a [Node.js](http://nodejs.org/) module generated by [lodash-cli](https://npmjs.org/package/lodash-cli).
+
+## Author
+
+| [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](https://twitter.com/jdalton "Follow @jdalton on Twitter") |
+|---|
+| [John-David Dalton](http://allyoucanleet.com/) |
+
+## Contributors
+
+| [![twitter/blainebublitz](http://gravatar.com/avatar/ac1c67fd906c9fecd823ce302283b4c1?s=70)](https://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [![twitter/kitcambridge](http://gravatar.com/avatar/6662a1d02f351b5ef2f8b4d815804661?s=70)](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|---|---|
+| [Blaine Bublitz](http://www.iceddev.com/) | [Kit Cambridge](http://kitcambridge.be/) | [Mathias Bynens](http://mathiasbynens.be/) |

src/convert/lodash/lodash._renative/index.js

@@ -0,0 +1,23 @@
+/**
+ * Lo-Dash 2.3.0 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modularize modern exports="npm" -o ./npm/`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Available under MIT license <http://lodash.com/license>
+ */
+
+/** Used for native method references */
+var objectProto = Object.prototype;
+
+/** Used to resolve the internal [[Class]] of values */
+var toString = objectProto.toString;
+
+/** Used to detect if a method is native */
+var reNative = RegExp('^' +
+  String(toString)
+    .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    .replace(/toString| for [^\]]+/g, '.*?') + '$'
+);
+
+module.exports = reNative;

src/convert/lodash/lodash._renative/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "lodash._renative",
+  "version": "2.3.0",
+  "description": "The internal Lo-Dash variable `reNative` as a Node.js module generated by lodash-cli.",
+  "homepage": "http://lodash.com/custom-builds",
+  "license": "MIT",
+  "author": "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+  "contributors": [
+    "John-David Dalton <john.david.dalton@gmail.com> (http://allyoucanleet.com/)",
+    "Blaine Bublitz <blaine@iceddev.com> (http://www.iceddev.com/)",
+    "Kit Cambridge <github@kitcambridge.be> (http://kitcambridge.be/)",
+    "Mathias Bynens <mathias@qiwi.be> (http://mathiasbynens.be/)"
+  ],
+  "bugs": "https://github.com/lodash/lodash-cli/issues",
+  "repository": { "type": "git", "url": "https://github.com/lodash/lodash-cli.git" }
+}