node-red-contrib-prib-functions 0.19.2 → 0.21.0

package/matrix/matrixNode.html

@@ -7,18 +7,20 @@
 			name: {value:null},
 			action: {value: "create",required:true},
 			args: {value:[]},
-			arg: {value:null},"arg-type": {value:"msg"},
 			call:{value:null},
-			column: {value:null},"column-type": {value:"num"},
-			columns: {value:null},"columns-type": {value:"num"},
+			column: {value:2},"column-type": {value:"num"},
+			columns: {value:2},"columns-type": {value:"num"},
+			dataType: {value:"Float32Array"},"columns-type": {value:"Float32Array"},
 			end: {value:null},"end-type": {value:"num"},
 			factor: {value:null},"factor-type": {value:"num"},
+			initialState:{value:"setZero"},
 			matrix: {value:"payload"},"matrix-type": {value:"msg"},
 			precision: {value:3},"precision-type": {value:"num"},
 			row: {value:3},"row-type": {value:"num"},
 			rows: {value:3},"rows-type": {value:"num"},
 			rowTarget: {value:null},"rowTarget-type": {value:"num"},
 			source: {value:"_matrix"},"source-type": {value:"msg"},
+			sourceArray: {value:"payload"},"sourceArray-type": {value:"msg,json,flow,global"},
 			start: {value:null},"start-type": {value:"num"},
 			target: {value:"_matrix"},"target-type": {value:"msg"},
 			value: {value:"payload"},"value-type": {value:"msg"},
@@ -35,70 +37,70 @@
 			return this.name || ("Matrix "+this.action||"*** new ***");
 		},
 		oneditprepare: function() {
+			console.log("+++")
 			const node=this;
 			node.properties=[];
 			node.editors=[];
 			const actions={
-				define:{label:"Define",show:["target"],args:["rows","columns"]},
-				defineEmpty:{label:"Define Empty",show:["target"],args:["rows","columns"]},
-				create:{label:"Create",show:["target"],args:[]},
-                createLike:{label:"Create Like",show:["source","target"],args:[]},
-                clone:{label:"Clone",show:["source","target"],args:[]},
                 add:{label:"Add",show:["source"],args:["matrix"]},
                 addRow:{label:"Add Row",show:["source"],args:["row","vector"]},
 				addRow2Row:{label:"Add Row to Row",show:["source"],args:["row","target","factor","start","end"]},
                 addCell:{label:"Add to Cell",show:["source"],args:["row","column","value"]},
-                subtractCell:{label:"Subtract Cell",show:["source","target"],args:["row","column","value"]},
-                multiple:{label:"Multiple",show:["source","target"],args:[]},
-                multipleCell:{label:"Multiple Cell",show:["source","target"],args:["rows","columns","value"]},
-                divideCell:{label:"Divide Cell",show:["source"],args:["rows","columns","value"]},
-                divideRow:{label:"Divide Row",show:["source"],args:["row","factor","start","end"]},
-                transpose:{label:"Transpose",show:["source","target"],args:[]},
-                getAdjoint:{label:"Adjoint",show:["source","target"],args:[]},
-                getCofactor:{label:"Cofactor",show:["source","target"],args:[]},
-                getComplementMinor:{label:"Complement Minor",show:["source","target"],args:[]},
-				getIdentity:{label:"Identity",show:["source","target"],args:[]},
-				getInverse:{label:"Inverse",show:["source","target"],args:[]},
-				getInverseAdjointMethod:{label:"Inverse (Adjoint Method)",show:["source","target"],args:[]},
-				getInverseGaussJordan:{label:"Inverse (Gauss Jordan Method)",show:["source","target"],args:[]},
-				norm:{label:"Norm",show:["source","target"],args:[]},
-				getDeterminant:{label:"Determinant",show:["source","target"],args:[]},
-				getDeterminantUsingCofactor:{label:"Determinant (Cofactor)",show:["source","target"],args:[]},
-				getDeterminantUsingCofactor:{label:"Determinant (Row Echelon Form)",show:["source","target"],args:[]},
                 backwardSubstitution:{label:"Backward Substitution",show:["source"],args:[]},
-				forwardElimination:{label:"Forward Elimination",show:["source"],args:[]},
-				gaussianElimination:{label:"Gaussian Elimination",show:["source"],args:[]},
-				reducedRowEchelonForm:{label:"Reduced Row EchelonForm",show:["source"],args:[]},
-				rowEchelonForm:{label:"Row Echelon Form",show:["source"],args:[]},
-                equalsNearly:{label:"Nearly Equals",show:["source"],args:[]},
-				testIsSquare:{label:"Is Square",show:["source"],args:[]},
-				get:{label:"Get Cell",show:["source","target"],args:[]},
-				sumRow:{label:"Sum Row",show:["source","target"],args:[]},
-				swapRows:{label:"Swap Rows",show:["source"],args:[]},
-				toArray:{label:"To Array Object",show:["source","target"],args:[]},
-				runningSum:{label:"Running Sum",show:["source","target"],args:[]},
-				getVandermonde:{label:"Vandermonde",show:["target"],args:["vector","columns"]},
-				create:{label:"Create",show:[,"target"],args:["rows","columns"]},
+				create:{label:"Create",         show:["target"],args:["initialState","rows","columns","dataType"]},
+                createLike:{label:"Create Like",show:["source","target"],args:[]},
+                clone:{label:"Clone",show:["source","target"],args:[]},
 				createForEachCellPairSet:{label:"Create Pair Set Cells",show:["source","target"],args:["matrix","call"],default:{call:"(baseCellValue,matrixCellValue)=>{}"}},
+				define:{label:"Define",show:["target"],args:["rows","columns","dataType"]},
+				defineEmpty:{label:"Define Empty",show:["target"],args:["rows","columns","dataType"]},
+				divideCell:{label:"Divide Cell",show:["source"],args:["rows","columns","value"]},
+                divideRow:{label:"Divide Row",show:["source"],args:["row","factor","start","end"]},
+                equalsNearly:{label:"Nearly Equals",show:["source"],args:[]},
+				fillArray:{label:"Fill",show:["source"],args:["matrix"]},
+				findColumnRow:{label:"Find in Column",show:["source"],args:["column","call","start","end"],default:{call:"()=>{}"}},
 				findRowColumn:{label:"Find in Row",show:["source"],args:["row","call","start","end"],default:{call:"(value,row,column,offset,vector)=>true"}},
 				forRowCells:{label:"Row Cells",show:["source"],args:["row","call","start","end"],default:{call:"()=>{}"}},
-				fillArray:{label:"fill",show:["source"],args:["matrix"]},
-				findColumnRow:{label:"Find in Column",show:["source"],args:["column","call","start","end"],default:{call:"()=>{}"}},
 				forColumnCells:{label:"Column Cells",show:["source"],args:["column","call","start","end"],default:{call:"()=>{}"}},
 				forEachCell:{label:"For Each Cell",show:["source"],args:["call"],default:{call:"()=>{}"}},
 				forEachRow:{label:"For Each Row",show:["source"],args:["call"],default:{call:"()=>{}"}},
 				forEachCellPairSet:{label:"For Each Cell Pair Set",show:["source"],args:["matrix","call"],default:{call:"()=>{}"}},
+				forwardElimination:{label:"Forward Elimination",show:["source"],args:[]},
+				gaussianElimination:{label:"Gaussian Elimination",show:["source"],args:[]},
+				get:{label:"Get Cell",show:["source","target"],args:[]},
+                getAdjoint:{label:"Adjoint",show:["source","target"],args:[]},
+                getCofactor:{label:"Cofactor",show:["source","target"],args:[]},
+                getComplementMinor:{label:"Complement Minor",show:["source","target"],args:[]},
+				getDeterminant:{label:"Determinant",show:["source","target"],args:[]},
+				getDeterminantUsingCofactor:{label:"Determinant (Cofactor)",show:["source","target"],args:[]},
+				getDeterminantUsingCofactor:{label:"Determinant (Row Echelon Form)",show:["source","target"],args:[]},
+				getIdentity:{label:"Identity",show:["source","target"],args:[]},
+				getInverse:{label:"Inverse",show:["source","target"],args:[]},
+				getInverseAdjointMethod:{label:"Inverse (Adjoint Method)",show:["source","target"],args:[]},
+				getInverseGaussJordan:{label:"Inverse (Gauss Jordan Method)",show:["source","target"],args:[]},
 				getIndex:{label:"Get Vector Offset",show:["source","target"],args:["row","column"]},
-				getZeroed:{label:"Get Zeroed",show:["source","target"],args:["row","column"]},
-				getMatrix:{label:"get Sub Matrix",show:["source","target"],args:["row","column","rows","columns"]},
+				getMatrix:{label:"Get Sub Matrix",show:["source","target"],args:["row","column","rows","columns"]},
 				getRow:{label:"Get Row",show:["source","target"],args:["row"]},
+				getVandermonde:{label:"Vandermonde",show:["target"],args:["vector","columns"]},
+				getZeroed:{label:"Get Zeroed",show:["source","target"],args:["row","column"]},
 				maxAbsColumn:{label:"Column Maximum Absolute",show:["source","target"],args:["column","start"]},
 				maxColumn:{label:"Column Max",show:["source","target"],args:["column","start"]},
+                multiple:{label:"Multiple",show:["source","target"],args:[]},
+                multipleCell:{label:"Multiple Cell",show:["source","target"],args:["rows","columns","value"]},
 				multiplyRow:{label:"Multiply Row",show:["source"],args:["row","factor"]},
+				norm:{label:"Norm",show:["source","target"],args:[]},
 				reduceRow:{label:"Reduce Row",show:["source","target"],args:["row","call","value"],default:{call:"(agregatevalue,cellValue,row,column)=>agregatevalue+cellValue"}},
+				reduce:{label:"Reduce Cells",show:["source","target"],args:["call","value"],default:{call:"()=>{}"}},
+				reducedRowEchelonForm:{label:"Reduced Row EchelonForm",show:["source"],args:[]},
+				rowEchelonForm:{label:"Row Echelon Form",show:["source"],args:[]},
+				runningSum:{label:"Running Sum",show:["source","target"],args:[]},
 				set:{label:"Set Cell",show:["source"],args:["row","column","value"]},
 				setRow:{label:"Set Row",show:["source"],args:["vector","row"]},
-				reduce:{label:"Reduce Cells",show:["source","target"],args:["call","value"],default:{call:"()=>{}"}}
+                subtractCell:{label:"Subtract Cell",show:["source","target"],args:["row","column","value"]},
+				sumRow:{label:"Sum Row",show:["source","target"],args:[]},
+				swapRows:{label:"Swap Rows",show:["source"],args:[]},
+				testIsSquare:{label:"Is Square",show:["source"],args:[]},
+				toArray:{label:"To Array Object",show:["source","target"],args:[]},
+                transpose:{label:"Transpose",show:["source","target"],args:[]}
 			};
 			const baseDiv=$("#node-inputDynamicBase");
 			function defineProperty(property,...types) {
@@ -118,16 +120,46 @@
 					const inputNode=$('<input type="text" id="node-input-'+property.name+'"/>').val(node[property.name]);
 					const typeNode=$('<input type="hidden" id="node-input-'+property.name+'-type"/>');
 					element.append([inputNode,typeNode]);
-					const typeValue=node[property.name+"-type"];
-					if(typeValue) typeNode.val(typeValue);
-					$("#node-input-"+property.name).typedInput({
-	  					type:typeValue||types[0],
-    					types:types,
-    					typeField: "#node-input-"+property.name+"-type"
-					});
+					if(types[0] instanceof Array) {
+						$("#node-input-"+property.name).typedInput({
+							type:property.name, 
+							types:[{value: property.name,
+    							options: types[0]
+							}]})
+					} else {
+						const typeValue=node[property.name+"-type"];
+					    if(typeValue) typeNode.val(typeValue);
+						$("#node-input-"+property.name).typedInput({
+	  						type:typeValue||types[0],
+    						types:types,
+    						typeField: "#node-input-"+property.name+"-type"
+						});
+					}
 				}
 			}
-			defineProperty({name:"source"	,label:"Source"		,icon:"crosshairs"},"msg","flow","global");
+			defineProperty({name:"initialState",label:"Initially"	,icon:"tag"},[
+        		{ value: "setZero", label: "Zeros"},
+        		{ value: "setRandom", label: "Random Numbers"},
+        		{ value: "setIdentity", label: "Identity"},
+				{ value: "setOne", label: "all 1"},
+				]);
+
+			defineProperty({name:"dataType",label:"number Type"	,icon:"tag"},[
+				{ value: "Float32Array", label: "float32	-3.4e38 to 3.4e38" },
+				{ value: "Float64Array", label: "double/float64	-1.8e308 to 1.8e308" },				{ value: "Int8Array", label: "byte -128 to 122" },
+				{ value: "Uint8Array", label: "octet 0 to 255" },
+				{ value: "Uint8ClampedArray", label: "octet clamped 0 to 255" },
+				{ value: "Int16Array", label: "short -32768 to 32767" },
+				{ value: "Uint16Array", label: "short unsigned  0 to 65535" },
+				{ value: "Int32Array", label: "	long -2147483648 to 2147483647" },
+				{ value: "Uint32Array", label: "long unsgined 0 to 4294967295" },
+				{ value: "BigInt64Array", label: "bigint 2**-263 to 2**263" },
+				{ value: "BigUint64Array", label: "bigint unsigned 0 to 2**264" },
+			]);
+
+
+
+			defineProperty({name:"source"	,label:"Source"		,icon:"crosshairs"},"msg","json","flow","global");
 			defineProperty({name:"arg"		,label:"Argument"	,icon:"tag"},"num","json","msg","flow","global","env");
 			defineProperty({name:"matrix"	,label:"Matrix"		,icon:"th"},"msg","flow","global");
 			defineProperty({name:"target"	,label:"Target"		,icon:"save"},"msg","flow","global");
@@ -145,8 +177,10 @@
 			defineProperty({name:"vector"	,label:"Vector"		,icon:"ellipsis-h"},"json","msg","flow","global");
 			defineProperty({name:"call"		,label:"Call"		,icon:"js",mode:"javascript"},"edit");
 
-			const options=Object.keys(actions).reduce((previousValue,property)=>previousValue.concat({value:property,label:actions[property].label}),
-				[]);
+			const options=Object.keys(actions)
+				.sort((a,b) => actions[a].label<actions[b].label?-1:0)
+				.reduce((previousValue,property)=>previousValue.concat({value:property,label:actions[property].label}),
+					[]);
 			const actionNode=$("#node-input-action");
 			actionNode.typedInput({
     			types: [{
@@ -154,7 +188,7 @@
             		options: options
 				}]
 			});
-	actionNode.change(function() {
+			actionNode.change(function() {
 				action=$(this).val();
 				node.args=[];
 				node.properties.forEach(property=>$(".form-row-http-in-"+property).hide());
@@ -162,7 +196,6 @@
 				node.args=actionDef.args;
 				node.args.forEach(property=>$(".form-row-http-in-"+property).show());
 				actionDef.show.forEach(property=>$(".form-row-http-in-"+property).show());
-
 			});
 		},
 		oneditsave: function() {

package/matrix/matrixNode.js

@@ -23,6 +23,7 @@ function evalInFunction(node,propertyName){
 		const property=node[propertyName];
 		if(property==null) throw Error("no value for "+propertyName);
 		const propertyType=propertyName+"-type";
+		if(! (propertyType in node)) return evalFunction(propertyName,"()=>node."+property) 
 		switch (node[propertyType]){
 		case "num":
 		case "json":
@@ -86,7 +87,11 @@ module.exports = function (RED) {
 			}	
 			node.argFunction=[];
 			node.args.forEach(property=>{
-				node.argFunction.push(evalInFunction(node,property).bind(this));
+				try{
+					node.argFunction.push(evalInFunction(node,property).bind(this));
+				} catch(ex) {
+					throw Error("args "+property+" "+ex.message)
+				}
 			})
 			function baseProcess(msg){
 				const sourceIn=node.getSource(msg);
@@ -99,14 +104,15 @@ module.exports = function (RED) {
 				node.setData.apply(node,[result,msg]);
 			}
 			function createProcess(msg){
-				const sourceIn=node.getSource(msg);
-				if(sourceIn==null) throw Error("source data not found");
-				const sourceMatrix=(sourceIn instanceof Matrix?sourceIn.clone():new Matrix(sourceIn));
+				if(logger.active) logger.sendInfo({label:"create",arg:{rowsMax:node.row,columns:node.column}});
+				const sourceMatrix=new Matrix({rowsMax:node.rows,columns:node.columns,dataType:node.dataType});
+				if(!(node.initialState in sourceMatrix)) throw Error("Invalid initial state "+node.initialState);
+				sourceMatrix[node.initialState]()
 				node.setData.apply(node,[sourceMatrix,msg]);
 			}
 			function defineProcess(msg){
 				if(logger.active) logger.sendInfo({label:"define",arg:{rows:node.row,columns:node.column}});
-				const sourceMatrix=new Matrix({rows:node.rows,columns:node.columns});
+				const sourceMatrix=new Matrix({rows:node.rows,columns:node.columns,dataType:node.dataType});
 				node.setData.apply(node,[sourceMatrix,msg]);
 			}
 			function defineEmptyProcess(msg){
@@ -152,6 +158,7 @@ module.exports = function (RED) {
 				node.msgProcess(msg);
 				node.send(msg);
 			} catch(ex) {
+				error(node,ex,"Invalid "+ex.message)
 				msg.error=ex.message;
 				node.send([null,msg]);
 				if(logger.active) logger.send({label:"error",node:node.id,action:node.action,exception:ex.message,stack:ex.stack});

package/monitor/BarGauge.js

@@ -0,0 +1,8 @@
+const getBarGauge=(max,min)=>{
+    return {action:"g",id:"barGauge",children:[
+      defs,
+      {action:"rect",x:x,y:y,width:width,height:height,children:[
+        {action:"animate",attributeName:"transform",values:"0;5;0",dur:"10s",repeatCount:"indefinite"}
+      ]},
+    ]}
+  }

package/monitor/Dataset.js

@@ -0,0 +1,29 @@
+function Dataset(settings) {
+    Object.assign(this,{values:[]},settings)
+}
+Dataset.prototype.addValue=function(v){
+    if(this.min==null) {
+      this.max=v
+      this.min=v
+      this.range=0
+      this.average=v
+    } else {
+      if(this.min>v){
+        this.min=v
+        this.range=this.max-this.min
+      } else if(this.max<v){
+        this.max=v
+        this.range=this.max-this.min
+      }
+      this.average+=(v-this.average)/(this.values.length+1) 
+    }
+    this.values.push(v)
+}
+Dataset.prototype.getMax=function(){return this.max}
+Dataset.prototype.getMin=function(){return this.min}
+Dataset.prototype.getAverage=function(){return this.average}
+Dataset.prototype.getFirst=function(){return this.values[0]}
+Dataset.prototype.getRange=function(){return this.range}
+Dataset.prototype.getLast=function(){return this.value.slice(-1)}
+
+module.exports=Dataset

package/monitor/DialGauge.js

@@ -0,0 +1,109 @@
+const defs=require("./defs.js")
+const DialNeedle=require("./DialNeedle.js")
+const boundValue=(v,max=100,min=0)=>Math.min(Math.max(v, min), max)
+const pi2=2 * Math.PI
+const pi2DegreeFactor=180 / Math.PI
+const toRadians=(degrees)=> degrees / pi2DegreeFactor
+const toDegrees=(radians)=> radians * pi2DegreeFactor
+function DialGauge(settings) {
+  Object.assign(this,{radius:100,value:0,gapAngle:80,color:"gray",min:0,max:100,title:"%"},settings)
+  this.range=this.max-this.min
+  if(this.range<=0) throw Error("invalid range, min>=max")
+  this.strokeWidth = this.radius * 0.3;
+  this.circumference = this.radius * pi2
+  this.dashOffset = this.circumference * this.gapAngle/380;
+  this.gaugeAngleArea=360-this.gapAngle
+  this.angleFactor=this.gaugeAngleArea/this.range
+  this.halfStrokeGap=(this.circumference-this.dashOffset)/2
+  this.strokeInnerRadius=this.radius - this.strokeWidth / 2
+  this.strokeInnerCircumference= this.strokeInnerRadius * pi2
+  this.strokeDashOffset = this.strokeInnerCircumference * this.gaugeAngleArea/360;
+  this.gauge={action:"circle",fill:"transparent",
+    cx:this.radius,cy:this.radius,r:this.strokeInnerRadius,stroke:"lightgray","stroke-width":this.strokeWidth,
+    "stroke-dasharray":this.getDashArray(this.max),
+    transform:{rotate:{angle:90+parseInt(this.gapAngle/2),x:this.radius,y:this.radius}}}
+  this.needle=new DialNeedle({radius:this.radius,startAngle:-this.gaugeAngleArea/2})
+  this.svg=this.getSvg()
+}
+DialGauge.prototype.get=function(value){
+  return this.svg
+}
+DialGauge.prototype.getSvg=function(){
+  const group=[]
+  group.push(Object.assign({},this.gauge,{stroke:"red"}))
+  group.push(Object.assign({},this.gauge,{stroke:"orange","stroke-dasharray":this.getDashArray(80)}))
+  group.push(Object.assign({},this.gauge,{stroke:"yellow","stroke-dasharray":this.getDashArray(60)}))
+  group.push(Object.assign({},this.gauge,{stroke:"lightgreen","stroke-dasharray":this.getDashArray(40)}))
+  group.push(Object.assign({},this.gauge,{stroke:"green","stroke-dasharray":this.getDashArray(20)}))
+  group.push(Object.assign({},this.gauge,{id:"dialColor",stroke:"lightgray","stroke-dasharray":this.getDashArrayReverse(0)}))
+/*
+  group.push({action:"clipPath",id:"clipGauge",children:[
+      Object.assign({},this.gauge,{id:"dialColor1","stroke-dasharray":this.getDashArray(0),"stroke-miterlimit":"10",stroke:"none",class:"heatGrad"})
+    ]})
+  group.push({action:"style",children:["circle.heatGrad {background: conic-gradient(red, orange, yellow, green); }"]})
+  group.push({action:"use",href:{id:"clipGauge"}})
+*/
+  group.push(this.getScale())
+  group.push({action:"text",x:this.radius,y:this.radius*1.5,"dominant-baseline":"middle","text-anchor":"middle",children:[this.title]})
+  group.push(this.needle.get(0))
+  return {action:"g",height:2*this.radius,children:[group]}
+/*        
+    {action:"clipPath",children:[
+      Object.assign({},this.gauge,{id:"dialColor","stroke-dasharray":this.getDashArray(0),stroke:"none",class:"grad"})
+    ]},
+    {action:"style",children:["circle.grad {background: conic-gradient(red, orange, yellow, green); }"]},
+    {action:"setConicGradient",id:"clip"}, 
+*/
+}
+
+DialGauge.prototype.getUpdate=function(value){
+  return [this.needle.getUpdate((value-this.min)*this.angleFactor),{action:"update",id:"dialColor","stroke-dasharray":this.getDashArrayReverse(value)}]
+}
+DialGauge.prototype.setMax=function(value){
+  this.max = value
+  this.range=this.max-this.min
+  if(this.range<=0) throw Error("invalid range, min>=max")
+  this.angleFactor=this.gaugeAngleArea/this.range
+  return this
+}
+DialGauge.prototype.getDashArray=function(value){
+  const ratio=(value-this.min)/this.range
+  const dash=this.strokeDashOffset*ratio
+  const gap=this.strokeInnerCircumference-dash
+  return dash+","+gap
+}
+DialGauge.prototype.getDashArrayReverse=function(value){
+  const ratio=(value-this.min)/this.range
+  const gap=this.strokeDashOffset*ratio
+  const dash=this.strokeDashOffset*(1-ratio) 
+  return "0,"+gap+","+dash+","+this.strokeDashOffset
+}
+
+DialGauge.prototype.getScale=function() {
+  const sr1 = this.radius;
+  const sr2 = this.radius - this.strokeWidth-5;
+  const srT = sr2 - 10;
+  const objDef=[]
+  let n = 0;
+  const increment=toRadians(this.gaugeAngleArea/10)
+  for (let sr = toRadians(-this.gaugeAngleArea); sr <= 0; sr += increment) {
+    const sra=sr + toRadians(90 - this.gapAngle/2)
+    const saCos=Math.cos(sra)
+    const saSin=Math.sin(sra)
+    objDef.push({action:"line",
+        x1:this.radius + sr1 * saCos,
+        y1:this.radius + sr1 * saSin,
+        x2:this.radius + sr2 * saCos,
+        y2:this.radius + sr2 * saSin}
+    )
+    objDef.push({action:"text",
+        x:this.radius + srT * saCos,
+        y:this.radius + srT * saSin,
+        children:[String(n*10)]
+    })
+    n++
+  }
+  return objDef;
+} 
+
+module.exports=DialGauge

package/monitor/DialNeedle.js

@@ -0,0 +1,36 @@
+function DialNeedle(settings) {
+    Object.assign(this,{
+      radius:100,
+      startAngle:0,
+      id:"needle",
+      baseDialSize:20,
+      value:{min:0,max:100}
+    },settings)
+    Object.assign(this,{
+      endAngle:this.endAngle??360-this.startAngle,
+      center:this.center??{x:this.radius,y:this.radius}
+    })
+    this.value.range=this.value.max-this.value.min
+    this.ratio=(this.endAngle-this.startAngle)/this.range,
+    this.svg=this.getSvg();
+}
+DialNeedle.prototype.get=function(value){
+    return this.svg
+}
+DialNeedle.prototype.getSvg=function(id=""){
+    return {action:"g",id:id+this.id,children:[
+      {action:"path",transform:{rotate:{angle:this.startAngle,x:this.radius,y:this.radius}},d:[
+          {action:"moveTo",x:this.radius,y:0},
+          {action:"deltaLineTo",x:-this.baseDialSize,y:this.radius},
+          {action:"deltaArc",radius:{x:this.baseDialSize,y:this.baseDialSize},x:this.baseDialSize*2,y:0},
+          {action:"Z"}
+          ],
+        fill:this.color,stroke:this.color
+      }
+    ]}
+}
+DialNeedle.prototype.getUpdate=function(angle){
+  if(angle>360 || angle < -360) throw Error("angle > 360 or < -360, angle: "+angle)
+  return {action:"update",id:this.id,transform:{rotate:{angle,x:this.radius,y:this.radius}}}
+}
+module.exports=DialNeedle

package/monitor/Format.js

@@ -0,0 +1,74 @@
+const Format={
+    NumberToAbbreviated:(value)=>{
+     if(typeof value!='number') value=parseFloat(value);
+     if (value>Math.pow(10,16)) return Math.round(value/Math.pow(10,15)).toString()+'P'
+     if (value>Math.pow(10,13)) return Math.round(value/Math.pow(10,12)).toString()+'T'
+     if (value>Math.pow(10,10)) return Math.round(value/Math.pow(10,9)).toString()+'G'
+     if (value>Math.pow(10,7)) return Math.round(value/Math.pow(10,6)).toString()+'M'
+     if (value>Math.pow(10,4)) return Math.round(value/Math.pow(10,3)).toString()+'K'
+     if (value == Math.round(value)) return value.toString()
+     if (value>=10000) return value.toFixed(0).toString()
+     if (value>=1000) return value.toFixed(1).toString()
+     if (value>=100) return value.toFixed(2).toString()
+     if (value>=10) return value.toFixed(3).toString()
+     return value.toString()
+    },
+    HexToString: (value)=>{
+       if(value==null) return null;
+       let valueString = '';
+       for (let i = 0; i < value.length; i += 2)
+           valueString += String.fromCharCode(parseInt(value.substr(i, 2), 16));
+       return valueString;
+    },
+    padLeadZero:(value,size)=>"000000000000".substr(0,size-value.toString().length)+value,
+    toString:(type,value)=>{
+      switch (type) {
+        case 'timestamp' :
+        case 'datetime' :
+        case 'time' :
+        case 'date' :
+          var ts = new Date();
+          ts.setTime(parseInt(value));
+          var axisLabel='';
+          switch (this.dataType[0]) {
+              case 'timestamp' :
+              case 'date' :
+              case 'datetime' :
+                if (this.precision[0] >= 1440) axisLabel+=ts.getFullYear()+'-';
+                if (this.precision[0] >= 1440) axisLabel+=Format.padLeadZero(ts.getMonth()+1,2)+'-';
+                if (this.precision[0] >= 1440) axisLabel+=Format.padLeadZero(ts.getDate(),2);
+                if (this.precision[0] >= 1440) axisLabel+=' ';
+              case 'time' :
+                if (this.precision[0] >= 360) axisLabel+=Format.padLeadZero(ts.getHours(),2)+':';
+                if (this.precision[0] >=  60) axisLabel+=Format.padLeadZero(ts.getMinutes(),2)+':';
+                if (this.precision[0] >=  1) axisLabel+=Format.padLeadZero(ts.getSeconds(),2);
+          }
+          return 	axisLabel;
+        case 'int' :
+        case 'real' :
+        case 'number' :
+          return format.NumberToAbbreviated(value)
+      }
+      return value.toString();
+    },
+    StringToHex:(value)=>{
+      if(value==null) return null;
+      let hex = '';
+      for(let i=0;i<value.length;i++) 
+        hex += ''+value.charCodeAt(i).toString(16);
+      return hex;
+    },
+    xmlEncodeString(value) {
+        if(value==null) return null;
+        return value.toString().replace(/([\&"<>])/g, function(str, item) {
+            return {
+                '&': '&amp;',
+                '"': '&quot;',
+                '<': '&lt;',
+                '>': '&gt;'
+            }[item];
+        });
+    }
+  }
+  
+module.exports=Format

package/monitor/centerElement.js

@@ -0,0 +1,14 @@
+function centerElement(elementIdToCenter) {
+    if(elementIdToCenter == null)	return;
+    const toCenter = document.getElementById(elementIdToCenter);
+    const width = toCenter.getWidth();
+    const height = toCenter.getHeight();
+    const elementParent = toCenter.ancestors();
+    const Pwidth = elementParent[0].getWidth();
+    const Pheight = elementParent[0].getHeight();
+    width = parseInt(Pwidth/2, 10) - parseInt(width/2, 10);
+    height = parseInt(Pheight/2, 10) - parseInt(height/2, 10);
+    toCenter.setStyle({'top': height + 'px'});
+    toCenter.setStyle({'left': width + 'px'});
+}
+module.exports=centerElement

package/monitor/compareElements.js

@@ -0,0 +1,95 @@
+function compareNodes(oldNode, newNode, compare) {      //  this function under construction
+    if( compare==null)
+        var compare= {
+             attribute: {
+                 match: function(attribute) {
+                     }
+                ,mismatch: function(oldAttribute,newAttribute) {
+                    return '<attribute key="'+oldAttribute.nodeName+'" old="'+oldAttribute.nodeValue+'" new="'+newAttribute.nodeValue+'"/>';
+                    }
+                ,missingNew: function(attribute) {
+                    return '<attribute key="'+attribute.nodeName+'" new="'+attribute.nodeValue+'"/>';
+                    } 
+                ,missingOld : function(attribute) {
+                    return '<attribute key="'+attribute.nodeName+'" old="'+attribute.nodeValue+'"/>';
+                    }
+                }
+            ,node: {
+                 isSameElement: function(oldNode,newNode) {
+                         if(oldNode.nodeType != newNode.nodeType) return false;
+                         if(oldNode.nodeType != 1) return true;
+                        return (oldNode.nodeName = newNode.nodeName);
+                     }
+                ,match: function(node) {
+                     }
+                ,mismatch: function(oldNode,newNode) {
+                        return '<pair><new th>"'+node.nodeValue+'</new></node>'
+                    }
+                ,missingNew: function(node) {
+                        return '<node key="'+node.nodeName+'"><new>"'+node.nodeValue+'</new></node>'
+                    } 
+                ,missingOld : function(node) {
+                        return '<node key="'+node.nodeName+'"><old>"'+node.nodeValue+'</old></node>'
+                    }
+                }
+            };
+    var diff="";
+    if(oldNode == null)
+        var oldAttributes=[] , oldNodes=[];
+    else 
+        var oldAttributes=oldNode.attributes , oldNodes=oldNode.childNodes;
+    if(newNode == null)
+        var newAttributes=[] , newNodes=[];
+    else 
+        var newAttributes=newNode.attributes , newNodes=oldNode.childNodes;
+    if( !compare.node.isSameElement(oldNode,newNode)   	
+    || oldNode.nodeValue != newNode.nodeValue )
+        diff += compare.node.mismatch(oldNode,newNode);
+    else
+        diff += compare.node.match(oldNode,newNode);
+    var o=0;n=0;
+    while (o<oldAttributes.length || n<newAttributes.length) {
+        var oldAttribute=oldAttributes[o],newAttribute=newAttributes[n];
+        if(oldAttributes.nodeName==newAttribute.nodeName) {
+            if(oldAttribute.nodeValue==newAttribute.nodeValue)
+                diff += compare.attribute.match(oldAttribute);
+            else
+                diff += compare.attribute.mismatch(oldAttribute,newAttribute);
+            o++;n++;
+            continue;
+        }
+        if(oldAttribute.nodeName>newAttribute.nodeName) {
+            diff += compare.attribute.missingNew(newAttribute);
+            n++;
+            continue;
+        }
+        diff+= compare.attribute.missingOld(oldAttribute);
+        o++;
+    }
+    for (o=o;oldAttributes.length;o++) diff += compare.attribute.missingOld(oldAttributes[o]);
+    for (n=n;newAttributes.length;n++) diff += compare.attribute.missingANew(newAttributes[n]);
+    o=0;n=0;
+    while (o<oldNodes.length || n<newNodes.length) {
+        var oldNode=oldNodes[o]; newNode=newNodes[n]; 
+        if(compare.node.isSameElement(oldNode,newNode)) {
+            diff+=compareNodes(oldNode,newNode,compare);
+            n++;o++;
+            continue;
+        }
+        for (i=o;i<oldNodes.length;i++)    // search for same element 
+            if(compare.node.isSameElement(oldNodes[i],newNode)) break;
+        for (j=n;j<newNodes.length;j++)    // search for same element
+            if(compare.node.isSameElement(oldNode,newNodes[j])) break;
+   
+        if(i>=oldNodes.length) i=9999; 
+        if(j>=newNodes.length) j=9999;
+        if((i-o)>(j-n))
+            for (n=n;n<j;n++) compare.node.missingNew(newNodes[n]);
+        else 
+            for (o=o;o<i;o++) compare.node.missingOld(oldNodes[o]);
+        continue;
+    }
+    for (o=o;o<oldNodes.length;o++) compare.node.missingOld(oldNodes[o]);
+    for (n=n;n<newNodes.length;n++) compare.node.missingNew(newNodes[n]);
+   }
+