node-red-contrib-prib-functions 0.22.0 → 0.23.3

package/lib/objectExtensions.js

@@ -1,71 +1,54 @@
-if(!Array.prototype.move)
-    Array.prototype.move = function(from, to) {
-         if(from<to) to--;
-         this.splice(to, 0, this.splice(from, 1)[0]);
-     };
-if(!Number.prototype.between)
-    Number.prototype.between  = function (min, max) {
-         return !(this < min || this > max);
-     };
-if(!String.prototype.in)
-    String.prototype.in = function (str) {
-         for (var i = 0; i < arguments.length; i++)
-             if(this==arguments[i]) return true;
-         return false;
-        };
-if(!String.prototype.startsWith)
-    String.prototype.startsWith = function (str) {
-         return this.slice(0, str.length) == str;
-        };
-if(!String.prototype.toTitle)
-    String.prototype.toTitle = function () {
-         var title=this.substr(0,1).toUpperCase()
-             ,lastLowerCase=false;
-         for(var i=1 ; i<this.length; i++ ) {
-             char=this.substr(i,1);
-             if(char==char.toUpperCase()) {
-                 if(lastLowerCase) title+=' ';
-                 lastLowerCase=false;
-                 if(char=='_') continue;
-                 if(char==' ') continue;
-             } else lastLowerCase=true;
-             title+=char;
-         }
-         return title;
-       };
-if(!String.prototype.to)
-    String.prototype.to = function (type) {
-        if (this==null) return null;
-        if (type==null) return value;
-        return this['to'+type.capitalize()];
+const defineMethod=(object,name,call)=>{
+    if(name in object.prototype) return
+    try{
+        Object.defineProperty(object.prototype, name, {
+            enumerable: false,
+              value: call
+        }) 
+    } catch(ex){
+        console.error("defining "+name,ex.message)
     }
-if(!String.prototype.toReal)
-    String.prototype.toReal = function () {
-        return parseFloat(this);
-    };
-if(!String.prototype.toInt)
- String.prototype.toInt = function () {
-        return parseInt(this);
-    };
-if(!String.prototype.toTimestamp)
-    String.prototype.toTimestamp = function () {
-        return Date.parse(this.substr(0,4)+'/'+this.substr(5,2)+'/'+this.substr(8,11))
-         + parseInt(this.substr(21,3));
-    };
-if(!String.prototype.toTime)
-    String.prototype.toTime = function () {
-        return  Date.parse(this);
-    };
-if(!String.prototype.toDatetime)
-    String.prototype.toDatetime = String.prototype.toTime;
-if(!String.prototype.toDate)
-    String.prototype.toDate = String.prototype.toTime;
-if(!String.prototype.CRLF2BR)
-    String.prototype.CRLF2BR = function () {
-        return  this.replace("\n\r","<br/>").replace("\n","<br/>");
-    };
+}
+const toDateType=aDate=>aDate instanceof Date? aDate : new Date(Date.parse(aDate))
+const toDateTypeZulu=aDate=>aDate instanceof Date? aDate : new Date(aDate)
+defineMethod(Array,'move',function(from, to) {
+    if(from<to) to--
+    this.splice(to, 0, this.splice(from, 1)[0])
+})
+defineMethod(String,"in",function (...str) {
+    for (var i = 0; i < arguments.length; i++)
+        if(this==arguments[i]) return true
+   return false
+})
+defineMethod(String,"capitalize",function() {return this.charAt(0).toUpperCase() + this.slice(1)})
+defineMethod(String,"toCapitalized",function() {return this.charAt(0).toUpperCase() + this.slice(1)})
+defineMethod(String,"to",function (type) {
+    if(type==null) return value
+    return this['to'+type.capitalize()]
+})
+defineMethod(String,"toReal",function (){return parseFloat(this)})
+defineMethod(String,"toTitle", function (){return this.replace(/\w\S*/g, text => text.capitalize())})
+
+defineMethod(String,"toTitleGrammatical", function (){   
+    const lowerCaseList = ['a', 'an', 'the', 'and', 'but', 'or', 'for', 'nor', 'as', 'at', 
+        'by', 'from', 'in', 'into', 'of', 'on', 'onto', 'to', 'with', 'yet', 'so','upon', 'like', 'over', 'plus', 'up', 'down', 'off', 'near'];
+    const title=this.replace(/\p{L}+/gu, (word)=>{
+        const wordLowerCase=word.toLowerCase()
+        return lowerCaseList.includes(wordLowerCase) ? wordLowerCase : word.capitalize()
+    })
+    return title.capitalize()
+})
+
+defineMethod(String,"toInt",function() {return parseInt(this)})
+if(!String.prototype.toInt) String.prototype.toInteger=String.prototype.toInt
+defineMethod(String,"toTimestamp",function () {
+    return Date.parse(this.substring(0,4)+'/'+this.substring(5,2)+'/'+this.substring(8,11))
+         + parseInt(this.substring(21,3));
+})
+defineMethod(String,"toTime",function () {return  Date.parse(this)})
+defineMethod(String,"CRLF2BR", function(){return  this.replace("\n\r","<br/>").replace("\n","<br/>")})
 
-Array.prototype.findSorted = function(searchElement,minIndex = 0,maxIndex = this.length - 1) {
+defineMethod(Array,"findSorted",function(searchElement,minIndex = 0,maxIndex = this.length - 1) {
     let currentIndex, currentElement
     while(minIndex <= maxIndex) {
         currentIndex = (minIndex + maxIndex) / 2 | 0
@@ -77,8 +60,8 @@ Array.prototype.findSorted = function(searchElement,minIndex = 0,maxIndex = this
         } else return currentIndex
     }
     return -minIndex
- }
- Array.prototype.addSorted = function(element) {
+ })
+ defineMethod(Array,"addSorted",function(element) {
    if(this.length){
     const position = -this.findSorted(element)
     if(position<0 ) return -position
@@ -87,15 +70,16 @@ Array.prototype.findSorted = function(searchElement,minIndex = 0,maxIndex = this
    }
    this.push(element)
    return 0
-}
-Object.prototype.addList = function(property,object) {
+})
+
+defineMethod(Object,"addList",function(property,object) {
     try{
         this[property].push(object)
     } catch(ex) {
         this[property]=[object]
     }
-}
-Object.prototype.addErrorFunctions = function(){ 
+})
+defineMethod(Object,"addErrorFunctions",function(){ 
     this.onError=function(call){
         if(this.errorStack) this.errorStack.push(call)
         else this.errorStack=[this.call]
@@ -113,8 +97,9 @@ Object.prototype.addErrorFunctions = function(){
         if(typeof ex == "string") throw Error(ex)
         throw ex
     }
-}
-if(!colourSmallList) var colourSmallList={
+})
+
+const colourSmallList={
     "Red":'#FF0000',
     "Turquoise":'#00FFFF',
     "Grass Green":'#408080',
@@ -132,7 +117,7 @@ if(!colourSmallList) var colourSmallList={
     "Light Purple":'#FF0080',  	 	
     "Dark Grey":'#808080'
 }
-if(!colours) var colours ={
+const colours ={
     AliceBlue: '#F0F8FF',
     AntiqueWhite: '#FAEBD7',
     Aqua: '#00FFFF',
@@ -282,8 +267,7 @@ if(!colours) var colours ={
     Yellow: '#FFFF00',
     YellowGreen: '#9ACD32'
 }
-
-String.prototype.csvLine=function(delimiter=",",quote='"'){
+defineMethod(String,"csvLine",function(delimiter=",",quote='"'){
     let i=this.length,j=i,charInQuote,result=[]
     if(i==0) return result
     delimiter:while(i--){
@@ -317,9 +301,8 @@ String.prototype.csvLine=function(delimiter=",",quote='"'){
     const v=this.substring(i+1,j)
     result.unshift(v.length?isNaN(v)? v : Number(v):null)
     return result
-}
-
-String.prototype.csvFile=function(delimiter=",",quote='"'){
+})
+defineMethod(String,"csvFile",function(delimiter=",",quote='"'){
     let i=this.length,j=i,charInQuote,result=[],line=[]
     if(i==0) return result
     line:while(i--){
@@ -358,4 +341,154 @@ String.prototype.csvFile=function(delimiter=",",quote='"'){
         result.unshift(line)
     }
     return result
+})
+
+defineMethod(Date,"isBetween",function(min, max) {return !(this < toDateType(min) || this > toDateType(max))}) 
+defineMethod(Number,"isBetween",function(min, max) {return !(this < min || this > max)})
+defineMethod(String,"isBetween",function(min, max) {return !(this < min || this > max)})
+defineMethod(Object,"toSimpleArray",function(prefix) {
+	const returnValue=[]
+	for (let property in this) {
+		if(this[property]==null || this[property].enumerable==null || this[property].enumerable)
+		  	returnValue.push([(prefix?prefix:"")+property,this[property],typeof this[property]])
+		}
+	return returnValue
+})
+defineMethod(Object,"toSimpleArrayIgnoreNulls",function(prefix) {
+	const returnValue=[]
+	for (let property in this) {
+		if(this[property]==null ) continue
+		if(this[property].enumerable==null || this[property].enumerable)
+		  	returnValue.push([(prefix?prefix:"")+property,this[property],typeof this[property]])
+		}
+	return returnValue
+})
+
+defineMethod(String,"in",function () {
+	for (let i = 0; i < arguments.length; i++)
+		if(this.toString()===arguments[i]) return true;
+	return false
+})
+defineMethod(String,"startsWithList",function () {
+	for (var i = 0; i < arguments.length; i++)
+		if(this.slice(0, arguments[i].length)===arguments[i]) return true
+	return false
+})
+defineMethod(String,"startsWithListAnyCase",function (...list) {
+	for (var i = 0; i < list.length; i++){
+        const testString=list[i].toLowerCase()
+		if(this.slice(0, testString.length).toLowerCase()==testString) return true
+    }
+	return false
+})
+defineMethod(String,"xmlStringEncode",function() {
+	return this.toString().replace(/([\&"<>])/g, function(str, item) {
+		return {
+			'&': '&amp;',
+			'"': '&quot;',
+			'<': '&lt;',
+			'>': '&gt;'
+		}[item]
+	});
+})
+
+defineMethod(Number,"toAbbreviated",function() {
+    const digits=(v,e)=>{
+        const nv=v/Math.pow(10,e)
+        const anv=Math.abs(nv)
+        if(anv<10)   return nv.toFixed(2).toString()    
+        if(anv<100)   return nv.toFixed(1).toString()
+        return nv.toFixed(0).toString()    
+    }
+    const a=Math.abs(this)
+	if(a>Math.pow(10,15)) return digits(this,15)+'P'
+	if(a>Math.pow(10,12)) return digits(this,12)+'T'
+	if(a>Math.pow(10,9)) return digits(this,9)+'G'
+	if(a>Math.pow(10,6)) return digits(this,6)+'M'
+	if(a>Math.pow(10,3)) return digits(this,3)+'K'
+	return digits(this,0)
+})
+
+defineMethod(BigInt,"toAbbreviated",function() {
+    const digits=(v,e)=>{
+        const nv=v/Math.pow(10,e)
+        const anv=Math.abs(nv)
+        if(anv<10)   return nv.toFixed(2).toString()    
+        if(anv<100)   return nv.toFixed(1).toString()
+        return nv.toFixed(0).toString()    
+    }
+    const a=Math.abs(this)
+	if(a>Math.pow(10,15)) return digits(this,15)+'P'
+	if(a>Math.pow(10,12)) return digits(this,12)+'T'
+	if(a>Math.pow(10,9)) return digits(this,9)+'G'
+	if(a>Math.pow(10,6)) return digits(this,6)+'M'
+	if(a>Math.pow(10,3)) return digits(this,3)+'K'
+	return digits(this,0)
+})
+
+
+defineMethod(String,"getWord",function(wordPosition) {return this.split(/\s+/g,wordPosition+1)[wordPosition-1]??""})
+
+const coalesce=(...args)=>{
+	for (var i=0; i<args.length; ++i)
+ 		if (args[i] !=  null) return args[i]
+	return null; 
+}
+const nullif=(a,b)=>{return a==b?null:a}
+//missing Float16Array,
+[ArrayBuffer,Number,Boolean,BigInt,Date,String,Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,BigInt64Array,BigUint64Array,Float32Array,Float64Array].forEach(type=>{
+  defineMethod(type,"deepClone",function(){ return new type(this)})
+})
+
+const getWord=(value,wordPosition)=>value.split(/\s+/g,wordPosition+1)[wordPosition-1]
+
+const deepClone=(deepObject) =>{
+	if(deepObject==null) return null;
+	if(deepObject instanceof Array) 
+		var newObj=[];
+	else if(deepObject instanceof String) 
+		return new String(deepObject);  
+	else if(deepObject instanceof Number) 
+		return new Number(deepObject);  
+	else if(deepObject instanceof Date)  
+		return new Date(deepObject);
+	else if(typeof deepObject == "object")
+		var newObj={};
+	else return deepObject;
+	for (const i in deepObject)
+		newObj[i]=deepClone(deepObject[i]);
+	return newObj;
 }
+
+defineMethod(Array,"deepClone",function(){
+    const clone=[]
+	for (let i in this)
+		clone[i]=this[i].deepClone()
+    return clone
+})
+defineMethod(Object,"deepClone",function(){
+//    const clone={}
+//	for (let i in this)
+//		clone[i]=this[i].deepClone()
+//    return clone
+    return deepClone(this)
+})
+const rangeLimit=(value,min=value,max=value)=>value<min?min:value>max?max:value
+defineMethod(Number, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(BigInt, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(Date, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(String, "rangeLimit",function(min,max) {return (min!=null && this<min) ? min : ((max!=null && this>max) ? max : this)})
+defineMethod(String,"deunderscore",function(){return this.replace(/_/g," ")})
+defineMethod(String,"deunderscoreCapitilize",function(){return this.replace(/_/g," ").toTitle()})
+defineMethod(String,"dropSquareBracketPrefix",function(bracket="[",endBracket="]"){return (this.substr(0,1)==bracket)? this.split(endBracket+" ")[1] : this})
+module.exports={
+    coalesce:coalesce,
+    colours:colours,
+    colourSmallList:colourSmallList,
+    deepClone,deepClone,
+    getWord,getWord,
+    nullif:nullif,
+    rangeLimit,rangeLimit,
+    toDateType,
+    toDateTypeZulu,
+}

package/lib/timeDimension.js

@@ -0,0 +1,36 @@
+const timePeriod={second:1000}
+timePeriod.minute=timePeriod.second*60
+timePeriod.hour=timePeriod.minute*60
+timePeriod.day=timePeriod.hour*24
+timePeriod.week=timePeriod.day*7
+timePeriod.fortnight=timePeriod.week*2
+
+const isPeriod={
+  second:t=>t%timePeriod.second,
+  minute:t=>t%timePeriod.minute
+}
+
+
+
+const timeDimension=(period=timePeriod.second,from=0,to=60,call)=>{
+  const fromDate=new Date(from).getMilliseconds%period
+  const toDate=new Date(to).getMilliseconds%increment
+  const periods=Object.keys(callFunctions)
+  for(let i=fromDate;i<toDate;i+increment){
+    call(i)
+  }
+}
+
+const repeat=(r,call)=>{for(let i=0;i<r; i++) call(i)}
+const secondsInMinute=call=>repeat(60,call)
+const minutesInHour=repeat(60,call)
+const hoursInDay=repeat(24,call)
+const daysInWeek=repeat(7,call)
+
+module.exports={
+  repeat:repeat,
+  secondsInMinute:secondsInMinute,
+  minutesInHour:minutesInHour,
+  hoursInDay:hoursInDay,
+  daysInWeek:daysInWeek
+}

package/lib/typedInput.js

@@ -0,0 +1,77 @@
+
+const setGetFunction=(RED,node,propertyName)=>node["get"+propertyName[0].toUpperCase() + propertyName.slice(1)]=getFunction(RED,node,propertyName)
+
+const getFunction=(RED,node,propertyName)=>{
+	try{
+		const property=node[propertyName];
+		if(property==null) throw Error("no value for "+propertyName);
+		const propertyType=propertyName+"Type";
+		if(! (propertyType in node)) return eval("()=>node."+property)
+        const type=node[propertyType]
+		switch (type){
+        case "bin": //	a Node.js Buffer
+        case "re": //	a Regular Expression
+        case "jsonata": //	a Jsonata Expression
+        case "cred": //	a secure credential
+        case "bool":
+        case "json":
+        case "num":
+        case "str":
+        case "date": //	the current timestamp
+        case "env":
+        case "global":
+            const value=RED.util.evaluateNodeProperty(property, type, node)
+            return eval("()=>value")
+        case "flow":
+            const flow = node.context().flow;
+			if(flow) throw Error("context store may be memoryonly so flow doesn't work")
+			return eval("()=>flow.get("+property+")");
+        case "msg":
+			return eval("(msg)=>msg."+property);
+        case "node":
+            const nodeContext = node.context();
+            return eval("()=>nodeContext.get("+property+")");
+        default:
+			throw Error("unknown type "+node[propertyType])
+		}
+	} catch(ex) {
+		throw Error(propertyName+" "+ex.message);
+	}
+    
+}
+const setFunction=(RED,node,name)=>{
+    if(!name) 
+    if(!node.hasOwnProperty(name)) throw Error("name is null")
+    if(!node.hasOwnProperty(name+"-type")) {
+        node.set[name]=eval("data=>msg.payload['"+name+"']=data)")
+        return
+    }
+    const type=node[name+"t-type"]
+    switch(type){
+        case "node":
+        node.set[name]=eval("data=>node.context().set("+node[name]+",data)")
+            break
+        case "flow":
+            const flow=node.context().flow
+            if(flow) throw Error("context store may be memory only so flow doesn't work")
+            node.set[name]=eval("data=>flow.set("+node[name]+",data)")
+            break
+        case "global":
+            node.set[name]=eval("data=>nodeContext.global.set("+node[name]+",data)")
+            break
+        case "msg":
+            node.set[name]=eval("(data,msg)=>{msg."+node[name]+"=data;}")
+            break
+        default:
+            throw Error("setData unknown type "+type)
+    }
+}
+
+const getValue=(RED,node,propertyName,defaultValue)=>propertyName in node?getFunction(RED,node,propertyName)():defaultValue
+
+module.exports={
+    getFunction:getFunction,
+    setFunction:setFunction,
+    setGetFunction:setGetFunction,
+    getValue:getValue
+}

package/matrix/matrixNode.html

@@ -146,7 +146,8 @@
 
 			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: "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" },

package/package.json

@@ -1,33 +1,34 @@
 {
 	"name": "node-red-contrib-prib-functions",
-	"version": "0.22.0",
+	"version": "0.23.3",
 	"description": "Node-RED added node functions.",
 	"dependencies": {
 		"avsc": ">=5.7.7",
 		"compressiontool": "*",
-		"fast-xml-parser": "^4.2.5",
-		"node": ">=0.6.13",
+		"fast-xml-parser": "^5.2.1",
+		"node": ">=22.15.0",
 		"node-red-contrib-logger": "latest",
 		"node-red-contrib-noderedbase": ">=0.0.16",
 		"node-red-contrib-prib-functions": "file:",
-		"npm": "^10.9.0",
+		"npm": "^11.3.0",
 		"xlsx": "*"
 	},
 	"devDependencies": {
-		"@node-red/runtime": ">=1.2.8",
-		"axios": ">=0.21.1",
-		"bcrypt": "^5.0.1",
-		"bl": "^5.0.0",
-		"mocha": "^9.2.2",
-		"node-red": "^3.0.2",
-		"node-red-node-test-helper": "^0.3.0"
+		"@node-red/runtime": ">=4.0.9",
+		"axios": ">=1.9.0",
+		"bcrypt": "^5.1.1",
+		"bl": "^6.1.0",
+		"mocha": "^11.2.2",
+		"node-red": ">=4.0.9",
+		"node-red-node-test-helper": ">=0.3.4"
 	},
 	"scripts": {
 		"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***'"
+		"test02": "mocha \"test/02*.js\"",
+		"startNodeRed": "node-red --userDir ./test/data --setting ./test/data/settings.js ./test/data/flow.json --title '***test nodered***'",
+		"sharesNodeRed": "node-red --userDir ./test/data/shares --setting ./test/data/shares/settings.js ./test/data/shares/flow.json --title '***shares nodered***'"
 	},
 	"repository": {
 		"type": "git",
@@ -117,6 +118,7 @@
 		"system",
 		"testing",
 		"test",
+		"tensor",
 		"translate",
 		"transform",
 		"transpose",