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

package/lib/Chart.js

@@ -0,0 +1,177 @@
+const { action, children } = require("../monitor/defs");
+
+const getColourPallet=()=>{
+  const colourPallet=[];
+  const delta=255/5;
+  for(let i=0;i<5;i++)
+      for(let j=0;j<5;j++)
+          for(let k=0;k<5;k++)
+              colourPallet.push('rgb(' + Math.floor(i*delta) + ',' + Math.floor(j*delta) + ','+ Math.floor(k*delta) +')')
+  return colourPallet
+}
+
+const baseColours =["Chartreuse","red","yellow","blue","pink","Cyan","Magenta","orange"]
+const colourPallet=getColourPallet()
+
+const getColors=(number)=>{
+  if(number<baseColours.length) return baseColours
+  const colours=[],r=colourPallet.length/number
+  for(let i=0; i<number; i++) 
+    colours[i]=colourPallet[Math.floor(i*r)];
+  return colours	
+}
+
+function Chart(properties){
+  Object.assign(this,{
+    height:1000,
+    width:1000,
+    labels:[],
+    fontSize:12,
+    scale:.4,
+    xGap:100,yGap:100,
+    type:"line",
+    normaliseDimension:"all"
+  },properties)
+  this.density??=Math.min(this.height,this.width)
+  return this;
+}
+Chart.prototype.getLabels=function(x=this.width/2, y=this.yGap, fontSize=this.fontSize/this.scale){
+  if(!this.colours) this.colours=getColors(this.labels.length)
+  return this.labels.reduce((previous,label,i)=>{
+    const yPos=y+i*(2+fontSize)
+    previous.children.push({action:"rect",fill:this.colours[i],x:x,y:yPos,width:fontSize,height:fontSize})
+    previous.children.push({action:"text",x:x+2+fontSize,y:yPos,"font-size":fontSize,"dominant-baseline":"hanging","text-anchor":"left",children:[label]})
+    return previous
+  },{action:"g",id:"ledgend",children:[]})
+}
+Chart.prototype.getAxis=function(){
+  let ticks=[]
+  this.strokeWidth??=5
+  const w=this.width??1
+  const h=this.height??1
+  for(let tick=this.xGap; tick<this.width; tick+=this.xGap) {
+    ticks.push([["M",tick,-2*this.strokeWidth],["L",tick,2*this.strokeWidth]])
+  }  
+  for(let tick=this.yGap; tick<this.height; tick+=this.yGap) {
+    ticks.push([["M",-2*this.strokeWidth,tick],["L",2*this.strokeWidth,tick]])
+  }
+  return {id:"axis",action:"path",stroke:"black","stroke-width":this.strokeWidth,
+    d:[["M",0,0],["L",0,this.height],["M",0,0],["L",this.width,0]].concat(ticks)}
+}
+Chart.prototype.getLinePath=function(points=[]){
+  if(!points.length) return []
+  const path=points.map((r)=>["L"].concat(r))
+  path[0][0]="M"
+  return path
+}
+Chart.prototype.getLine=function(points=[],colour=black){
+  return {action:"path",d:getLinePath(points),stroke:colour}
+}
+Chart.prototype.getLineUpdate=function(points=[],colour=black){
+  return {action:"update",d:getLinePath(points)}
+}
+Chart.prototype.getYPoints=function(points=this.normalisedData){
+  if(!points) {
+    this.normalise()
+    points=this.normalisedData
+  }
+  if(!points.length) return [] // no columns
+  const xScale=this.width/(points[0].length-1)
+  const lines=points.map(y=>([["M",0,y[0]*this.height]]))
+  for(let c=1;c<points.length;c++) {
+    const column=lines[c]
+    points[c].forEach((y,x)=>column.push(["L",x*xScale,y*this.height]))
+  }
+  return lines
+}
+Chart.prototype.getYLines=function(){
+  if(this.data.length==0 || this.data[0].length==0) return []
+  if(!this.colours) this.colours=getColors(this.data[0].length)
+  return this.getYPoints().reduce((a,c,i)=>{
+    a.push({action:"path",id:"l"+i,d:c,stroke:this.colours[i],fill:"none","stroke-width":2*this.strokeWidth})
+    return a
+  },[])
+}
+Chart.prototype.getYLinesUpdate=function(){
+  return this.getYPoints().reduce((a,c,i)=>{a.push({action:"update",id:"l"+i,d:c});return a},[])
+}
+Chart.prototype.scalePoints=function(points,...ratios){
+   return points.map(p=> ratios.map((r,i)=>r*p[i]))
+}
+Chart.prototype.normalise=function(points=this.data){
+  const _this=this
+  if(points.length<1){
+    this.normalisedData=[]
+    return this.normalisedData
+  }
+  this.mins=[...points[0]]
+  this.maxs=[...points[0]]
+  for(let i=1; i<points.length;i++){
+    const row=points[i]
+    row.forEach((c,ci)=>{
+      if(c<_this.mins[ci]) _this.mins[ci]=c
+      else if(c>_this.maxs[ci]) _this.maxs[ci]=c
+    })
+  }
+  this.ranges=this.mins.map((min,i)=> _this.maxs[i]-min)
+  this.min=Math.min(...this.mins)
+  this.max=Math.max(...this.maxs)
+  this.range=this.max-this.min
+  this.normalisedData=this.ranges.map(c=>new Float32Array(points.length))
+  if(this.normaliseDimension="all") {
+    points.forEach((row,rowIndex)=>
+      row.forEach((inCell,columnIndex)=>
+        _this.normalisedData[columnIndex][rowIndex]=_this.range?((inCell-_this.min)/_this.range):0
+  )
+    )
+  } else {
+    this.ranges.forEach((range,columnIndex)=>{
+      const min=_this.mins[columnIndex]
+      points.forEach((row,rowIndex)=>
+        _this.normalisedData[columnIndex][rowIndex]=range?(row[columnIndex]- min)/range:0
+      )
+    })
+  }
+  return this.normalisedData
+}
+
+Chart.prototype.normalise2ChartBoundaries=function (points=this.normalisedData) {
+  return this.normalisedData.map(row=>row.map(v=>v*this.density))
+}
+Chart.prototype.getBubbles=function (points,colour) {
+  return points.map((a,row,i)=>({action:"circle",fill:colour,cx:row[0],cy:row[1],r:row[2],stroke:this.outline,"stroke-width":1, opacity:0.5}))
+}
+Chart.prototype.get=function () {
+  if(this.getData) {
+    this.data=this.getData()
+    this.normalisedData=null
+  }
+  if(!this.base) {
+    this.base=[]
+    if(!["pie"].includes(this.type)) this.base.push(this.getAxis())
+  }
+  const scaledHeight=this.scale*this.height
+  return {action:"g",height:scaledHeight+2*this.fontSize,id:"chart",
+    transform:{scale:{x:this.scale,y:this.scale},translate:{y:scaledHeight}},
+    children:[
+      {action:"g",children:this.base.concat(this.getYLines()),transform:{scale:{x:1,y:-1}}},
+      this.getLabels()
+    ]
+  }
+}
+Chart.prototype.getUpdate=function () {
+  if(this.getDataUpdate) {
+    this.data=this.getDataUpdate()
+    this.normalisedData=null
+  } else if(this.getData) {
+     this.data=this.getData()
+     this.normalisedData=null
+  }
+  return this.getYLinesUpdate()
+}
+Chart.prototype.setData=function (points) {
+  this.data=points
+  this.normalise()
+  return this
+}
+module.exports=Chart

package/lib/Column.js

@@ -0,0 +1,99 @@
+require("../lib/objectExtensions")
+const dataConversionFunction ={
+    real: parseFloat,
+    int: parseFloat,
+    number: parseFloat,
+    timestamp: (value)=>Date.parse(value.substr(0,4)+'/'+value.substr(5,2)+'/'+value.substr(8,11))
+           + parseInt(value.substr(21,3)),
+   time:Date.parse,
+   datetime:Date.parse,
+   date: Date.parse
+}
+function Column(properties) {
+    Object.assign(this,{type:null,index:[]},properties)
+    if(this.table==null) this.error("no table object") 
+    if(this.columnIndex==null) this.error("no columnIndex") 
+    if(this.name==null) this.error("no column name") 
+    if(this.title==null) this.title=this.name 
+    if(!this.types.includes(this.type)) this.error("invalid type: "+this.type+ " types: "+this.MeasureTypes.join(","))
+}
+Column.prototype.getNormalised=function(value){
+    try{
+        return this.normaliseRatio*(value-this.min)
+    } catch(ex){}
+    if(!this.max) throw Error("maximum value not set")
+    if(!this.min) throw Error("minimum value not set")
+    if(!this.range) throw Error("range value not set")
+    if(!this.normaliseRatio) throw Error("normalised ratio not set")
+}
+Column.prototype.buildColumnnar=function(){
+    const index=this.index
+    let max=this.table.data[0][index],min=max
+    this.columnar=this.table.data.reduce((a,row)=>{
+        const v=row[index]
+        if(v==null) return
+        try{
+            a[v].push(row)
+        } catch(ex) {
+            a[v]=[row]
+        }
+        if(max<v) max=v
+        else if(min>v) min=v
+    },{})
+    this.setMin(min).setMax(max)
+}
+Column.prototype.getMax=function(){
+    if(this.max) return this.max
+    if(!this.columnar) ths.buildColumnar()
+    return this.max
+}
+Column.prototype.setMax=function(value){
+    this.max=value
+    return this.setRange()
+}
+Column.prototype.setMin=function(value){
+    this.min=value
+    return this.setRange()
+}
+Column.prototype.setRange=function(min=this.min,max=this.max){
+    if(this.isMetric) {
+        this.range=max-min
+        this.normaliseRatio=this.range?1:1/this.range  
+    }
+    return this
+}
+Column.prototype.onError=function(call){
+    if(this.errorStack) this.errorStack.push(call)
+    else this.errorStack=[this.call]
+    return this
+}
+Column.prototype.error=function(ex="no error message"){
+    if(this.errorStack){
+      this.errorStack.forEach((callFunction)=>{
+          try{
+          callFunction(ex)
+          }catch(ex) {}
+      })
+      return
+    }
+  if(typeof ex == "string") throw Error(ex)
+  throw ex
+}
+Column.prototype.timeTypes=['timestamp','time','date','datetime']
+Column.prototype.isTime=(type=this.type)=>{
+    if(Column.prototype.timeTypes.includes(type)) return true
+    throw Error(column.name +" not time type")
+}  
+Column.prototype.types=['real','double','int','number','bigint',"string"]
+Column.prototype.numericTypes=['real','double','int','number','bigint']
+Column.prototype.isNumeric=(type=this.type)=>{
+    if(Column.prototype.numericTypes.includes(type)) return true
+    throw Error(column.name +" not numeric")
+}
+
+Column.prototype.MeasureTypes=['real','double','int','number','bigint','timestamp','date']
+Column.prototype.isMeasure=(type=this.type)=>{
+    if(Column.prototype.measureTypes.includes(type)) return true
+    throw Error(column.name +" not a measure")
+}  
+module.exports=Column 

package/lib/GraphDB.js

@@ -0,0 +1,14 @@
+require("../lib/objectExtensions")
+function GraphDB(properties){
+    Object.assign(this,{type:null,vertices:[],edges:[]},properties)
+
+}
+GraphDB.prototype.addVertex=function(vertex) {
+    this.vertices.addList(vertex)
+}
+GraphDB.prototype.addEdge=function(from,to) {
+    this.edges.addList({from:from,to:to})
+}
+
+this.addErrorFunctions()
+module.exports=GraphDB  

package/lib/Table.js

@@ -0,0 +1,185 @@
+const Column=require("../lib/Column")
+function Table(properties) {
+    Object.assign(this,{columns:[],columnNames:{},data:[],lists:{}},properties)
+}
+Table.prototype.error=function(ex){
+    if(this.errorStack){
+        this.errorStack.forEach((callFunction)=>{
+            try{
+                callFunction(ex)
+            }catch(ex) {}
+        })
+        return
+    }
+    if(typeof ex == "string") throw Error(msg)
+    throw ex
+}
+
+Table.prototype.onError=function(call){
+    if(this.errorStack) this.errorStack.push(call)
+    else this.errorStack=[this.call]
+    return this
+}
+Table.prototype.error=function(msg="no error message"){
+    const ex=typeof msg == "string"?msg=Error(msg):msg
+    if(this.errorStack){
+      this.errorStack.forEach((callFunction)=>{
+          try{
+          callFunction(msg)
+          }catch(ex2) {}
+      })
+      return
+    }
+    throw ex
+}
+Table.prototype.addColumn=function(values){
+    values.table=this
+    values.columnIndex=this.columns.length
+    const column=new Column(values)
+    if(column.name in this.columnNames) return this.error("dupicate column "+column.name)
+    this.columnNames[column.name]=this.columns.length
+    this.columns.push(column)
+    return this
+}
+Table.prototype.getcolumn=function(name){
+    return this.columns[this.columnNames[name]]
+}
+Table.prototype.columnNumbers=function(list=[],error=this.error){
+    try{
+        return list.map(c=>this.columnNames[c])
+    } catch(ex){
+        error(ex)
+    }
+}
+Table.prototype.forColumnNames=function(list=[],callFunction,error=this.error,workArea={}){
+    this.forColumnNumbers(this.columnNumbers(list),callFunction,error)
+    return this
+}
+Table.prototype.forColumnNumbers=function(list=[],callFunction,error=this.error){
+    list.forEach((columnNumber,i)=>{
+        try{
+            callFunction.apply(this,[this.columns[columnNumber],i,error,workArea])
+        } catch(ex){
+            error(ex)
+        }
+    })
+    return this
+}
+Table.prototype.forEachColumn=function(callFunction,columns=this.columns,filter,error=this.error,workArea={}){
+    for(let i=0; i<columns.length; i++)	{
+        const column=columns[i]
+        try{
+            if(filter && filter(column) ) continue
+            callFunction.apply(this,[column,i,error,workArea])
+        } catch(ex){
+            onEror(ex)
+        }
+    }
+    return this
+}
+
+Table.prototype.forEachRow=function(callFunction,filter,error=this.error,workArea={}){
+    for(let i= 0; i<this.data.length; i++)	{
+        const row=this.data[i]
+        try{
+            if(filter && filter(row) )continue
+            callFunction.apply(this,[row,i,error,workArea])
+        } catch(ex){
+            error(ex)
+        }
+    }
+    return this
+}
+Table.prototype.forEachRowColumns=function(columnNumbers,callFunction,filter,error=this.error,workArea={}){
+    this.forEachRow((row,i)=>{
+        if(filter && filter(row) ) return
+        const newRow=columnNumbers.map((columnIndex)=>row[columnIndex])
+        callFunction.apply(this,[newRow,i,row,workArea,error])
+    },error)
+    return this
+}
+Table.prototype.forEachRowDelta=function(callFunction,filter,error=this.error,workArea={}){
+    if(data.length<2) return
+    let last=this.data[0]
+    for(let i=1; i<this.data.length; i++){
+        const current=this.data[i]
+        if(filter && filter(current) ) continue
+        try{
+            const row=[]
+            this.list.delta.numbers().forEach(i=>{
+                row.push(current[i]-last[i])
+            })
+            callFunction.apply(this,[row,i])
+        } catch(ex){
+            error(ex)
+        }
+    }
+    return this
+}
+Table.prototype.buildColumnIndices=function(){
+    this.columns.forEach((column,i)=>column.buildColumnnar())
+    return this
+}
+Table.prototype.forEachRowGroup=function(callFunction,filter,error=this.error,workArea={}){
+    if(this.data.length==0) return [];
+    const group=this.lists.group.numbers
+    let sums=[]
+    groupValues=group.map(c=>row[c]) 
+    data.forEachRow((row,i,error,workArea)=>{
+        if(filter && filter(current) ) return
+        let diff=group.find((c,i)=>groupValues[i]!=row[c])
+        if(diff) {
+            callFunction(groupValues,sums,error)
+            for(;diff<group.length;diff++){
+                groupValues[diff]!=row[group[diff]]
+            }
+            workArea.groupValues=group.map(c=>row[c])
+        } else {
+            cnt++
+            measures.forEach((c,i)=>workArea.sums[i]+=row[c])
+        }
+    },null,error,workArea)
+
+
+    for(let i=0; i<this.data.length; i++) {
+        const column=this.table.columns[i]
+        try{
+            const l=data.find((element,idx) => element!=data[group[idx]] )
+            if(l) {
+                measureFunctions.forEach((measureFunction,mIndx)=>{
+                    measures[mIndx]=measureFunction(measures[mIndx],row)
+                })
+                continue
+            }
+            callFunction.apply(this,[data,measures])
+            data=group.map(c=>this.data[c])
+        } catch(ex){
+            error(ex)
+        }
+    }
+    return this
+}
+
+Table.prototype.getSelectHTML=function(list=[],onClick,filter=(column)=>true,multiple='multiple="multiple"'){
+  let options=""
+  if(typeof list == "string") list=this.grouping.split(',')
+  this.forEachColumn((column,i)=>{
+      if(filter(column==true)) return
+      options+='<option value="'+column.name+'" '+(list.includes(column.name)?'selected="selected"':"")+'>'+column.title+'</option>'
+  })
+  return '<select '+multiple+' onclick="'+onClick+'"/>'+options+'</select>'
+}
+Table.prototype.setDelta=function(list){
+    setListProperty("delta",list,(c)=>c.isMeasure())
+    return this
+}
+Table.prototype.setGroup=function(list){
+    setListProperty("group",list)
+    return this
+}
+Table.prototype.setListProperty=function(property,list,filter=()=>true) {
+    const listArrray={names:list instanceof Array?list:list.join(","),numbers:[]}
+    this.lists[property].numbers=this.columnNumbers(listArrray.names)
+    return this
+}
+module.exports=Table