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

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]);
+   }
+   

package/monitor/defs.js

@@ -0,0 +1,23 @@
+const heatGradient=[
+  {action:"stop",offset:"5%","stop-color":"lightgreen"},
+  {action:"stop",offset:"80%","stop-color":"yellow"},
+  {action:"stop",offset:"95%","stop-color":"red`"}
+]
+const heatGradientReverse=[
+  {action:"stop",offset:"95%","stop-color":"lightgreen"},
+  {action:"stop",offset:"20%","stop-color":"yellow"},
+  {action:"stop",offset:"5%","stop-color":"red`"}
+]
+
+const defs=
+  {action:"defs",children:[
+    {action:"style",children:[".red2green { background: conic-gradient(red, orange, yellow, green)}"]},
+    {action:"linearGradient",id:"heatGradientAcross",children:heatGradient},
+    {action:"linearGradient",id:"heatGradientAcrossCircle",x1:"0%",y1:"0%",x2:"100%",y2:"0%",children:heatGradient},
+    {action:"linearGradient",id:"heatGradientAcrossReverse",children:heatGradientReverse},
+    {action:"linearGradient",id:"heatGradientDown",children:heatGradient,gradientTransform:"rotate(90)"},
+    {action:"linearGradient",id:"heatGradientDownReverse",children:heatGradientReverse,gradientTransform:"rotate(90)"},
+    {action:"radialGradient",id:"heatGradientRadial",cx:"50%",cy:"50%",r:"50%",fx:"50%",fy:"50%",children:heatGradient}
+  ]}
+
+module.exports=defs