node-red-contrib-prib-functions 0.18.0 → 0.20.4

package/monitor/svgHTML.js

@@ -0,0 +1,179 @@
+const { action } = require("./defs");
+
+function drawSVGElement(element,p,baseId) {
+    if(p==null) throw Error("No properities")
+    const el=typeof element === "string"?document.getElementById(element):element
+    if(el==null) throw Error("element not found or null for "+element)
+    if (p.constructor === String)
+        return el.appendChild(document.createTextNode(p));
+    if(p instanceof Array) {
+        for(var i=0;i<p.length;i++) {
+            drawSVGElement(el,p[i],baseId);
+        }
+        return;
+    }
+    if(p.action=="clear"){
+        el.parentNode.replaceChild(el.cloneNode(false), el);
+        return;
+    }
+    if(p.action=="update"){
+      return updateSVGElement(el,p,baseId)
+    }
+    if(["setStyle","setConicGradient"].includes(p.action)){
+      return drawSVGElement(el,getSetStyle("#"+baseId+p.id),baseId)
+    }
+    let newEl = document.createElementNS("http://www.w3.org/2000/svg", p.action);
+    if(newEl==undefined) throw Error("svg invalid function "+p.action);
+    updateSVGElement(newEl,p,baseId)
+    el.appendChild(newEl);
+    return newEl;
+};
+function getSVGTransform(t){ 
+  const result= (t.translate?(" translate( " + (t.translate.x??0) + " "+ (t.translate.y??" ")+")" ):"") +
+    (t.scale?(" scale( "+t.scale.x+" "+(t.scale.y??" ")+")"):"") +
+    (t.rotate?(" rotate( "+t.rotate.angle+" "+(t.rotate.x??" ")+" "+(t.rotate.y??" ")+")"):"") +
+    (t.matrix?(" matrix( "+t.matrix.map(c=>c instanceof Array?c.join(","):c).join(" ")+")"):"") +
+    (t.skewX?(" skewX( "+t.skewX+")"):"") +
+    (t.skewY?(" skewY( "+t.skewY+")"):"")
+  if(result=="") throw Error("no valid transform for "+t)
+  return result
+} 
+const svgArray2Points=(a)=>a.map(c=>c.join(',')).join(" ")
+
+function getSVGPath(t){
+  return t.reduce((p,c,i)=>{
+    if(typeof c !== "object") return p+" "+ c
+    if(c instanceof Array) {
+//      if(c.length && c[0] instanceof Array) return p+" "+getSVGPath(c) 
+//      return p+" "+c.join(" ")
+      return p+" "+getSVGPath(c)
+    }
+    try{
+      switch (c.action){
+        case "M":
+        case "moveTo":
+          return p+"M "+c.x+" "+c.y+" "
+        case "m":
+        case "deltaMoveTo":
+          return p+"m "+c.x+" "+c.y+" "
+        case "L":
+        case "lineTo":
+          return p+"L "+c.x+" "+c.y+" "
+        case "l":
+        case "deltaLineTo":
+          return p+"l "+c.x+" "+c.y+" "
+        case "H":
+        case "horizontalLineTo":
+          return p+"H "+c+" "
+        case "h":
+        case "deltaHorizontalLineTo":
+          return p+"h "+c+" "
+        case "V":
+        case "verticalLineTo":
+          return p+"V "+c+" "
+        case "v":
+        case "deltaVerticalLineTo":
+          return p+"h "+c+" "
+        case "A":
+        case "arc":
+          return p+"A "+c.radius.x+" "+c.radius.y+" "+(c.angle??0)+" "+(c.large?1:0)+" "+(c.sweep?1:0)+c.x+" "+c.y+" "
+        case "a":
+        case "deltaArc":
+          return p+"a "+c.radius.x+" "+c.radius.y+" "+(c.angle??0)+" "+(c.large?1:0)+" "+(c.sweep?1:0)+c.x+" "+c.y+" "
+        case "Q":
+          return p+"Q "+c.x1+" "+c.y1+" "+c.x+" "+c.y+" "
+        case "q":
+          return p+"q "+c.x1+" "+c.y1+" "+c.x+" "+c.y+" "
+        case "T":
+          return p+"T "+c.x+" "+c.y+" "
+        case "t":
+          return p+"t "+c.x+" "+c.y+" "
+        case "C":
+          return p+"C "+c.x1+" "+c.y1+" "+c.x2+" "+c.y2+" "+c.x+" "+c.y+" "
+        case "c":
+          return p+"c "+c.x1+" "+c.y1+" "+c.x2+" "+c.y2+" "+c.x+" "+c.y+" "
+        case "S":
+          return p+"S "+c.x2+" "+c.y2+" "+c.x+" "+c.y+" "
+        case "s":
+          return p+"s "+c.x2+" "+c.y2+" "+c.x+" "+c.y+" "
+        case "Z":
+        case "z":
+        case "close":
+          return p+"Z "
+        default: throw Error("unknown path action: "+c.action)
+        }
+      } catch(ex) {
+        throw Error(ex.message+ " in "+JSON.stringify(c))     
+      }
+    },"")
+}
+function updateSVGElement(element,p,baseId="") {
+  if(p.action=="update" && p.id) {
+    element= document.getElementById(baseId+p.id)
+    if(element==null) throw Error("element id not found for "+baseId+p.id)
+    if(element instanceof SVGTextElement) {
+      while (element.firstChild) {
+        element.removeChild(element.firstChild);
+      }
+    }
+  }
+  const el=typeof element === "string"?document.getElementById(baseId+element):element
+  if(el==null) throw Error("element not found or null for "+baseId+element)
+  for(var a in p){
+      if(a=="action") continue;
+      if(a=="children" && p[a] instanceof Array) {
+          drawSVGElement(el,p[a],baseId);
+          continue;
+      }
+      if(a instanceof Function) {
+          el.addEventListener((p.substr(0,2)=="on"?p.substr(2):p), a.bind(this), false);
+          continue;
+      }
+      const pa=p[a]
+      if(typeof pa==="object"){
+        switch (a) {
+          case "points":
+            el.setAttributeNS(null, a, svgArray2Points(pa));
+            continue
+          case "path":
+          case "d":
+            const path=getSVGPath(pa)
+              el.setAttributeNS(null, a, path)
+            continue
+          case "href":
+            el.setAttributeNS(null, a, "url("+pa.id?"#"+ baseId+pa.id +")":"" )
+            continue 
+          case "transform":
+            const v=getSVGTransform(pa)
+            el.setAttributeNS(null, a, v);
+            continue 
+          case "viewBox":
+            el.setAttributeNS(null, a, svgArray2Points((pa.x??0)+" "+(pa.y??0) +" "+(pa.width??0)+" "+(pa.height??0)));
+            continue 
+          case "stroke":
+            let style=""
+            if(pa.class) style+="url(."+baseId+pa.url+")"
+            if(pa.element) style+="url(#"+baseId+pa.element+")"
+            el.setAttributeNS(null, a, style);
+            continue 
+          default:
+            throw Error("unknown "+p.action+" property"+a)
+        }
+      }
+      try{
+        el.setAttributeNS(null, a, (a=="id"?baseId:"")+pa);
+      } catch(ex) {
+          throw Error("failed set attribute "+a+" to "+pa+" error "+ex.message)
+      }
+  }
+  switch (p.action){
+      case "foreignObject" :
+          el.setAttributeNS(null, "requiredExtensions", "http://www.w3.org/1999/xhtml");
+          break;
+  }
+  return el;
+};
+
+const getSetStyle = (id,value="background: conic-gradient(red, orange, yellow, green);")=>{
+  return {action:"style",children:[id+" { "+value+" }"]}
+}

package/monitor/svgObjects.js

@@ -0,0 +1,64 @@
+const { off } = require("process")
+const { isAsyncFunction } = require("util/types")
+const Dataset=require("./Dataset.js")
+const defs=require("./defs.js")
+const color={green:"#5ee432",yellow:"#fffa50",orange:"#f7aa38",red:"#ef4655"}
+
+const svcTextLine=(metricLabel,value)=>{
+  return [{action:"style",children:[".svcTextLine {font: italic 13px sans-serif}"]},
+      {action:"text",height:10,class:"svcTextLine",children:[metricLabel+": "+value]}
+  ]
+}
+const calculatePositionVertically=(a,offset=0)=>{
+  const l=a.length
+  if(!l) return
+  let aPrevious=a[0]
+  if(aPrevious.transform) aPrevious={action:'g',height:aPrevious.height,children:[aPrevious]}
+  aPrevious.transform={translate:{y:offset}}
+  for(let i=1;i<l;i++){
+    let aCurrent=a[i]
+    if(aCurrent.transform) aCurrent={action:'g',height:aCurrent.height,children:[aCurrent]}
+    if(!aCurrent) throw Error("action is null for "+i +" in "+JSON.stringify(a))
+    if(!aPrevious.height) console.error("calculatePositionVertically no height")
+    aCurrent.transform={translate:{y:aPrevious.transform.translate.y+aPrevious.height}}
+    aPrevious=aCurrent
+  }
+  return a
+}
+
+const moveTransform = (x,y)=>[[1,0,x],[0,1,y]]
+const boundValue=(v,max=100,min=0)=>Math.min(Math.max(v, min), max)
+const twoPi=2 * Math.PI
+const getCircumference=(radius)=>radius*twoPi
+const getAcLength = (radius,angle)=> getCircumference(radius) * (angle / 360)
+const getArcDasharray=(radius,angle)=>{
+  const circumference = getCircumference(innerRadius)
+  const arc = circumference * (angle / 360)
+  return {strokeDasharray: ""+arc+" "+circumference}
+}
+const getElementWidth=(e)=>parseInt(window.getComputedStyle(e, null).getPropertyValue("width"))
+
+
+const geBarChart=(dataPoint=[],size,x,y)=>{
+    const min=Math.min(...dataPoint)
+    const max=Math.min(...dataPoint)
+    const range=max-min
+    const norm=range/size
+    return dataPoint.reduce((p,c,i)=>{
+        const delta=(c-min)/norm
+        x+=c
+        p.push({action:"rect",x:x,y:y,width:w,height:h,fill:fill[0]})
+        return p
+    },[])
+  }
+
+const DialGauge = require("./DialGauge.js")
+//const dialGauge=new DialGauge()
+const Chart = require("../lib/Chart.js")
+  
+module.exports={
+  barGauge:null,
+  Chart:Chart,
+  DialGauge:DialGauge,
+  calculatePositionVertically:calculatePositionVertically
+}

package/package.json

@@ -1,12 +1,17 @@
 {
 	"name": "node-red-contrib-prib-functions",
-	"version": "0.18.0",
+	"version": "0.20.4",
 	"description": "Node-RED added node functions.",
 	"dependencies": {
-		"avsc": "^5.6.1",
-		"fast-xml-parser": "^3.19.0",
-		"node-red-contrib-logger": "^0.0.6",
-		"xlsx": "^0.17.0"
+		"avsc": ">=5.7.7",
+		"compressiontool": "*",
+		"fast-xml-parser": "^4.2.5",
+		"node": ">=0.6.13",
+		"node-red-contrib-logger": "latest",
+		"node-red-contrib-noderedbase": ">=0.0.16",
+		"node-red-contrib-prib-functions": "file:",
+		"npm": "^10.9.0",
+		"xlsx": "*"
 	},
 	"devDependencies": {
 		"@node-red/runtime": ">=1.2.8",
@@ -14,11 +19,15 @@
 		"bcrypt": "^5.0.1",
 		"bl": "^5.0.0",
 		"mocha": "^9.2.2",
-		"node-red": "^2.2.2",
-		"node-red-node-test-helper": "^0.2.7"
+		"node-red": "^3.0.2",
+		"node-red-node-test-helper": "^0.3.0"
 	},
 	"scripts": {
-		"test": "mocha \"test/matrix/**/*.js\""
+		"test": "mocha \"test/dataAnalysisE*.js\"",
+		"test2": "mocha \"test/transformNum*.js\"",
+		"test00": "mocha \"test/00*.js\"",
+		"test04": "mocha \"test/04*.js\"",
+		"startNodeRed": "node-red --userDir ./test/data --setting ./test/data/settings.js ./test/data/flow.json --title '***test nodered***'"
 	},
 	"repository": {
 		"type": "git",
@@ -36,14 +45,20 @@
 		"backward substitution",
 		"compare",
 		"Complement Minor",
+		"compression",
 		"CMA",
 		"cumulative",
 		"Cumulative Moving Average",
 		"data",
 		"data analysis",
+		"decompression",
+		"deflate",
 		"delta",
 		"determinant",
 		"distance",
+		"difference",
+		"seasonal difference",
+		"second order difference",
 		"euclidian distance",
 		"EMA",
 		"EWMA",
@@ -53,9 +68,11 @@
 		"gauss jordan",
 		"Gauss Jordan Inverse",
 		"gaussian elimination",
+		"gzip",
 		"host available",
 		"host status",
 		"identity",
+		"inflate",
 		"injector",
 		"inverse",
 		"inverse matrix",
@@ -66,6 +83,7 @@
 		"matrix",
 		"maximum",
 		"mean",
+		"memory",
 		"median",
 		"minimun",
 		"model",
@@ -92,11 +110,13 @@
 		"stddev",
 		"spawn",
 		"spawn process",
+		"system",
 		"testing",
 		"test",
 		"translate",
 		"transform",
 		"transpose",
+		"unzip",
 		"variance",
 		"weighted",
 		"Weighted Moving Average",
@@ -106,9 +126,11 @@
 		"xcel",
 		"xml",
 		"XML",
+		"zip",
 		"Z-score"
 	],
 	"node-red": {
+		"version": ">=2.0.0",
 		"nodes": {
 			"append": "append/append.js",
 			"dataAnalysis": "dataAnalysis/dataAnalysis.js",
@@ -117,6 +139,7 @@
 			"load-injector": "testing/load-injector.js",
 			"matrix": "matrix/matrixNode.js",
 			"monitorflow": "monitor/monitorflow.js",
+			"monitorSystem": "monitor/monitorSystem.js",
 			"os": "nodejs/os.js",
 			"spawnProcess": "spawnProcess/spawnProcess.js",
 			"test": "testing/test.js",

package/test/00-objectExtensions.js

@@ -0,0 +1,94 @@
+const assert=require('assert');
+const should=require("should");
+require("../lib/objectExtensions");
+
+describe('/lib/objectExtensions array ', function() {
+	it("array find sorted empty set", function(done) {
+        assert.strictEqual([].findSorted("1"),-0)
+        done()
+    })
+	it("array find sorted [1] for 1", function(done) {
+        assert.strictEqual(["0"].findSorted("0"),0)
+        done()
+    })
+	it("array find sorted [1] for 2", function(done) {
+        assert.strictEqual(["0"].findSorted("1"),-1)
+        done()
+    })
+	it("array find sorted matches", function(done) {
+        assert.strictEqual(["0","1"].findSorted("1"),1)
+        assert.strictEqual(["0","1","2"].findSorted("1"),1)
+        assert.strictEqual(["0","1","2"].findSorted("2"),2)
+        done()
+    })
+	it("array find sorted misses", function(done) {
+        assert.strictEqual(["1","3","5"].findSorted("0"),-0)
+        assert.strictEqual(["1","3","5"].findSorted("2"),-1)
+        assert.strictEqual(["1","3","5"].findSorted("4"),-2)
+        assert.strictEqual(["1","3","5"].findSorted("6"),-3)
+        done()
+    })
+	it("array add sorted empty set", function(done) {
+        const result=[]
+        result.addSorted("1")
+        console.log(result)
+        assert.strictEqual([].addSorted("1"),0)
+        done()
+    })
+	it("array add sorted [1] for 1", function(done) {
+        assert.strictEqual(["1"].addSorted("1"),-0)
+        done()
+    })
+	it("array add sorted [1] for 2", function(done) {
+        assert.strictEqual(["1"].addSorted("2"),1)
+        done()
+    })
+	it("array add sorted matches", function(done) {
+        assert.strictEqual(["1","2"].addSorted("2"),1)
+        assert.strictEqual(["1","2","3"].addSorted("2"),1)
+        assert.strictEqual(["1","2","3"].addSorted("3"),2)
+        done()
+    })
+	it("array add sorted misses", function(done) {
+        const list=["1","3","5"]
+        assert.strictEqual(list.addSorted("0"),0)
+        assert.deepStrictEqual(list,["0","1","3","5"])
+        assert.strictEqual(list.addSorted("2"),2)
+        assert.deepStrictEqual(list,["0","1","2","3","5"])
+        assert.strictEqual(["0","1","2","3","5"].addSorted("4"),4)
+        assert.strictEqual(list.addSorted("4"),4)
+        assert.deepStrictEqual(list,['0',"1","2","3","4","5"])
+        done()
+    })
+	it("array add sorted misses at lend", function(done) {
+        assert.strictEqual(["1","3","5"].addSorted("6"),3)
+        done()
+    })
+})
+describe('/lib/objectExtensions object', function() {
+	it("addList", function(done) {
+        const list={}
+        list.addList("1",1)
+        assert.deepStrictEqual(list,{"1":[1]})
+        list.addList("1",2)
+        assert.deepStrictEqual(list,{"1":[1,2]})
+        list.addList("3",3)
+        assert.deepStrictEqual(list,{"1":[1,2],"3":[3]})
+        list.addList("2",4)
+        assert.deepStrictEqual(list,{"1":[1,2],"3":[3],"2":[4]})
+        done()
+    })
+})
+describe('/lib/objectExtensions csvLine', function() {
+	it("standard", function(done) {
+        assert.deepStrictEqual("".csvLine(),[])
+        assert.deepStrictEqual("1".csvLine(),[1])
+        assert.deepStrictEqual("1,2".csvLine(),[1,2])
+        assert.deepStrictEqual("1,,2".csvLine(),[1,null,2])
+        assert.deepStrictEqual("first,,last".csvLine(),["first",null,"last"])
+        assert.deepStrictEqual("\"first\",,\"last\"".csvLine(),["first",null,"last"])
+        assert.deepStrictEqual("\"first\",\"abc - 123\",\"~!@#$%^&*()_+-=`{}[]:;'|\\ <,>.?/\",\"last\"".csvLine()
+                                   ,["first","abc - 123","~!@#$%^&*()_+-=`{}[]:;'|\\ <,>.?/","last"])
+        done()
+    })
+})

package/test/01-base.js

@@ -0,0 +1,88 @@
+const assert=require('assert');
+const should=require("should");
+const helper=require("node-red-node-test-helper");
+const storageDefinition=require("../nodes/storageDefinition.js");
+const storageRead = require('../nodes/storageRead.js');
+
+helper.init(require.resolve('node-red'));
+
+function getAndTestNodeProperties(o) {
+	const n = helper.getNode(o.id);
+	for(let p in o) n.should.have.property(p, o[p]);
+	return n;
+}
+
+const blockStorage={
+	id : "blockStorage",
+	type : "Storage Definition",
+	name : "Block Storage",
+	action: "blockStorage",
+	sourceProperty:"blockStorageFile",
+	blockSize:4096
+};
+
+const StorageReadBlock={
+	id : "StorageReadBlockid",
+	type : "Storage Read",
+	name : "Block Storage",
+	target:"payload",
+	"target-type":"msg",
+	key:"topic"
+};
+
+function testFlow(done,node,data,result) {
+	const flow = [
+		Object.assign(node,{wires : [ [ "outHelper" ],["errorHelper"] ]}),
+		{id :"outHelper",	type : "helper"},
+		{id :"errorHelper",	type : "helper"}
+	];
+	helper.load(storageDefinition, flow, function() {
+		const n=getAndTestNodeProperties(node);
+		const outHelper = helper.getNode("outHelper");
+		const errorHelper = helper.getNode("errorHelper");
+		outHelper.on("input", function(msg) {
+			console.log("outHelper "+JSON.stringify(msg.payload));
+			if(JSON.stringify(msg.payload)==JSON.stringify(result)) {
+				done();
+			} else {
+				console.log("mismatch  expected: "+JSON.stringify(result) +" returned: "+JSON.stringify(msg.payload));
+				done("mismatch");
+			}
+		});
+		errorHelper.on("input", function(msg) {
+			console.log("errorHelper "+JSON.stringify(msg));
+			done("error  check log output");
+		});
+		n.receive({
+			topic:"test",
+			payload : data
+		});
+	});
+}
+
+describe('Storage Defintion', function() {
+	beforeEach(function(done) {
+		helper.startServer(done);
+	});
+	afterEach(function(done) {
+		helper.unload();
+		helper.stopServer(done);
+	});
+	it("load config", function(done) {
+		helper.load(storageDefinition,[], function() {
+			const n=getAndTestNodeProperties(storageDefinition);
+		});
+		done();
+	});
+	it("load read", function(done) {
+		helper.load(storageDefinition,storageRead,[], function() {
+			const n=getAndTestNodeProperties(storageDefinition);
+		});
+		done();
+	});
+	
+	it('read 1', function(done) {
+		const msg={topic:1}
+		testFlow(done,storageDefinition,msg,msg);
+	});
+});

package/test/04-tables.js

@@ -0,0 +1,33 @@
+//const assert=require('assert');
+const assert = require('node:assert/strict');
+const Table=require("../lib/Table");
+describe('/lib/Table ', function() {
+    const data=[[11,12,"one"],[1,2,"one"],[21,22,"two"],[21,22,"three"]]
+	it("add column", function(done) {
+        const table=new Table({data:data})
+        assert.throws(()=>table.addColumn({type:"notvalid"},/^no column name$/))
+//        table.addColumn({name:"col1"})
+        assert.throws(()=>table.addColumn({name:"col1"}),/^Error: invalid type: null.*$/)
+        assert.throws(()=>table.addColumn({name:"col1",type:"notvalid"}),/^Error: invalid type: notvalid.*$/)
+        done()
+    })
+	it("columnar", function(done) {
+        const table=new Table({data:data})
+        .addColumn({name:"c1",type:"int"})
+        .addColumn({name:"c2",type:"real"})
+        .addColumn({name:"c3",type:"string"})
+        .buildColumnIndices()
+        done()
+    })
+})
+
+const GraphDB=require("../lib/GraphDB");
+describe('/lib/GraphDB ', function() {
+	it("add vertex", function(done) {
+        const nodes=[{},{}]
+        const graphDB=new GraphDB()
+        graphDB.addVertex(nodes[0])
+        graphDB.addEdge(nodes[0],nodes[1])
+        done()
+    })
+})