@node-red/nodes 2.2.2 → 3.0.0-beta.1

package/core/common/60-link.js

@@ -14,10 +14,119 @@
  * limitations under the License.
  **/
 
+/**
+ * @typedef LinkTarget
+ * @type {object}
+ * @property {string} id - ID of the target node.
+ * @property {string} name - Name of target Node
+ * @property {number} flowId - ID of flow where the target node exists
+ * @property {string} flowName - Name of flow where the target node exists
+ * @property {boolean} isSubFlow - True if the link-in node exists in a subflow instance
+ */
+
+
 module.exports = function(RED) {
     "use strict";
-
     const crypto = require("crypto");
+    const targetCache = (function () {
+        const registry = { id: {}, name: {} };
+        function getIndex(/** @type {[LinkTarget]}*/ targets, id) {
+            for (let index = 0; index < (targets || []).length; index++) {
+                const element = targets[index];
+                if (element.id === id) {
+                    return index;
+                }
+            }
+            return -1;
+        }
+        /**
+         * Generate a target object from a node
+         * @param {LinkInNode} node 
+         * @returns {LinkTarget} a link target object
+         */
+        function generateTarget(node) {
+            const isSubFlow = node._flow.TYPE === "subflow";
+            return {
+                id: node.id,
+                name: node.name || node.id,
+                flowId: node._flow.flow.id,
+                flowName: isSubFlow ? node._flow.subflowDef.name : node._flow.flow.label,
+                isSubFlow: isSubFlow
+            }
+        }
+        return {
+            /**
+             * Get a list of targets registerd to this name
+             * @param {string} name Name of the target
+             * @param {boolean} [excludeSubflows] set `true` to exclude 
+             * @returns {[LinkTarget]} Targets registerd to this name.
+             */
+            getTargets(name, excludeSubflows) {
+                const targets = registry.name[name] || [];
+                if (excludeSubflows) {
+                    return targets.filter(e => e.isSubFlow != true);
+                }
+                return targets;
+            },
+            /**
+             * Get a single target by registered name.
+             * To restrict to a single flow, include the `flowId`
+             * If there is no targets OR more than one target, null is returned
+             * @param {string} name Name of the node
+             * @param {string} [flowId] 
+             * @returns {LinkTarget} target
+             */
+            getTarget(name, flowId) {
+                /** @type {[LinkTarget]}*/
+                let possibleTargets = this.getTargets(name);
+                /** @type {LinkTarget}*/ 
+                let target;
+                if (possibleTargets.length && flowId) {
+                    possibleTargets = possibleTargets.filter(e => e.flowId == flowId);
+                }
+                if (possibleTargets.length === 1) {
+                    target = possibleTargets[0];
+                }
+                return target;
+            },
+            /**
+             * Get a target by node ID
+             * @param {string} nodeId ID of the node
+             * @returns {LinkTarget} target
+             */
+            getTargetById(nodeId) {
+                return registry.id[nodeId];
+            },
+            register(/** @type {LinkInNode} */ node) {
+                const target = generateTarget(node);
+                const tByName = this.getTarget(target.name, target.flowId);
+                if (!tByName || tByName.id !== target.id) {
+                    registry.name[target.name] = registry.name[target.name] || [];
+                    registry.name[target.name].push(target)
+                }
+                registry.id[target.id] = target;
+                return target;
+            },
+            remove(node) {
+                const target = generateTarget(node);
+                const tn = this.getTarget(target.name, target.flowId);
+                if (tn) {
+                    const targs = this.getTargets(tn.name);
+                    const idx = getIndex(targs, tn.id);
+                    if (idx > -1) {
+                        targs.splice(idx, 1);
+                    }
+                    if (targs.length === 0) {
+                        delete registry.name[tn.name];
+                    }
+                }
+                delete registry.id[target.id];
+            },
+            clear() {
+                registry = { id: {}, name: {} };
+            }
+        }
+    })();
 
     function LinkInNode(n) {
         RED.nodes.createNode(this,n);
@@ -27,12 +136,14 @@ module.exports = function(RED) {
             msg._event = n.event;
             node.receive(msg);
         }
+        targetCache.register(node);
         RED.events.on(event,handler);
         this.on("input", function(msg, send, done) {
             send(msg);
             done();
         });
         this.on("close",function() {
+            targetCache.remove(node);
             RED.events.removeListener(event,handler);
         });
     }
@@ -74,31 +185,69 @@ module.exports = function(RED) {
     function LinkCallNode(n) {
         RED.nodes.createNode(this,n);
         const node = this;
-        const target = n.links[0];
+        const staticTarget = typeof n.links === "string" ? n.links : n.links[0];
+        const linkType = n.linkType;
         const messageEvents = {};
-        let timeout = parseFloat(n.timeout || "30")*1000;
+
+        let timeout = parseFloat(n.timeout || "30") * 1000;
         if (isNaN(timeout)) {
             timeout = 30000;
         }
+        function getTargetNode(msg) {
+            const dynamicMode = linkType === "dynamic";
+            const target = dynamicMode ? msg.target : staticTarget
 
-        this.on("input", function(msg, send, done) {
-            msg._linkSource = msg._linkSource || [];
-            const messageEvent = {
-                id: crypto.randomBytes(14).toString('hex'),
-                node: node.id,
+            ////1st see if the target is a direct node id
+            let foundNode;
+            if (targetCache.getTargetById(target)) {
+                foundNode = RED.nodes.getNode(target)
+            }
+            if (target && !foundNode && dynamicMode) {
+                //next, look in **this flow only** for the node
+                let cachedTarget = targetCache.getTarget(target, node._flow.flow.id);
+                if (!cachedTarget) {
+                    //single target node not found in registry! 
+                    //get all possible targets from regular flows (exclude subflow instances)
+                    const possibleTargets = targetCache.getTargets(target, true);
+                    if (possibleTargets.length === 1) {
+                        //only 1 link-in found with this name - good, lets use it
+                        cachedTarget = possibleTargets[0];
+                    } else if (possibleTargets.length > 1) {
+                        //more than 1 link-in has this name, raise an error
+                        throw new Error(`Multiple link-in nodes named '${target}' found`);
+                    }
+                }
+                if (cachedTarget) {
+                    foundNode = RED.nodes.getNode(cachedTarget.id);
+                }
+            }
+            if (foundNode instanceof LinkInNode) {
+                return foundNode;
             }
-            messageEvents[messageEvent.id] = {
-                msg: RED.util.cloneMessage(msg),
-                send,
-                done,
-                ts: setTimeout(function() {
-                    timeoutMessage(messageEvent.id)
-                }, timeout )
-            };
-            msg._linkSource.push(messageEvent);
-            var targetNode = RED.nodes.getNode(target);
-            if (targetNode) {
-                targetNode.receive(msg);
+            throw new Error(`target link-in node '${target || ""}' not found`);
+        }
+        this.on("input", function (msg, send, done) {
+            try {
+                const targetNode = getTargetNode(msg);
+                if (targetNode instanceof LinkInNode) {
+                    msg._linkSource = msg._linkSource || [];
+                    const messageEvent = {
+                        id: crypto.randomBytes(14).toString('hex'),
+                        node: node.id,
+                    }
+                    messageEvents[messageEvent.id] = {
+                        msg: RED.util.cloneMessage(msg),
+                        send,
+                        done,
+                        ts: setTimeout(function () {
+                            timeoutMessage(messageEvent.id)
+                        }, timeout)
+                    };
+                    msg._linkSource.push(messageEvent);
+                    targetNode.receive(msg);
+                }
+            } catch (error) {
+                node.error(error, msg);
             }
         });
 

package/core/common/lib/debug/debug-utils.js

@@ -581,12 +581,45 @@ RED.debug = (function() {
         var metaRow = $('<div class="red-ui-debug-msg-meta"></div>').appendTo(msg);
         $('<span class="red-ui-debug-msg-date">'+ getTimestamp()+'</span>').appendTo(metaRow);
         if (sourceNode) {
-            $('<a>',{href:"#",class:"red-ui-debug-msg-name"}).text('node: '+(o.name||sourceNode.name||sourceNode.id))
+
+            var nodeLink = $('<a>',{href:"#",class:"red-ui-debug-msg-name"}).text("node: "+(o.name||sourceNode.name||sourceNode.id))
             .appendTo(metaRow)
             .on("click", function(evt) {
                 evt.preventDefault();
                 config.messageSourceClick(sourceNode.id, sourceNode._alias, sourceNode.path);
             });
+
+            if (sourceNode.pathHierarchy) {
+                RED.popover.create({
+                    tooltip: true,
+                    target:nodeLink,
+                    trigger: "hover",
+                    size: "small",
+                    direction: "bottom",
+                    interactive: true,
+                    content: function() {
+                        const content = $("<div>")
+                        sourceNode.pathHierarchy.forEach((pathPart,idx) => {
+                            const link = $("<a>", {href:"#" ,style:'display: block'})
+                                .css({
+                                    paddingLeft:((idx*10)+((idx === sourceNode.pathHierarchy.length - 1)?10:0))+"px",
+                                    paddingRight:'2px'
+                                })
+                                .text(pathPart.label)
+                                .appendTo(content)
+                                .on("click", function(evt) {
+                                    evt.preventDefault();
+                                    config.messageSourceClick(pathPart.id);
+                                })
+                            if (idx < sourceNode.pathHierarchy.length - 1) {
+                                $('<i class="fa fa-angle-down" style="margin-right: 3px"></i>').prependTo(link)
+                            }
+                        })
+                        return content
+                    },
+                    delay: { show: 50, hide: 150 }
+                });
+            }
         } else if (name) {
             $('<span class="red-ui-debug-msg-name">'+name+'</span>').appendTo(metaRow);
         }

package/core/function/10-function.html

@@ -355,27 +355,41 @@
         color:"#fdd0a2",
         category: 'function',
         defaults: {
-            name: {value:""},
+            name: {value:"_DEFAULT_"},
             func: {value:"\nreturn msg;"},
             outputs: {value:1},
-            noerr: {value:0,required:true,validate:function(v) { return !v; }},
+            noerr: {value:0,required:true,
+                    validate: function(v, opt) {
+                        if (!v) {
+                            return true;
+                        }
+                        return RED._("node-red:function.error.invalid-js");
+                    }},
             initialize: {value:""},
             finalize: {value:""},
-            libs: {value: [], validate: function(v) {
+            libs: {value: [], validate: function(v, opt) {
                 if (!v) { return true; }
                 for (var i=0,l=v.length;i<l;i++) {
                     var m = v[i];
                     if (!RED.utils.checkModuleAllowed(m.module,null,installAllowList,installDenyList)) {
-                        return false
+                        return RED._("node-red:function.error.moduleNotAllowed", {
+                            module: m.module
+                        });
                     }
                     if (m.var === "" || / /.test(m.var)) {
-                        return false;
+                        return RED._("node-red:function.error.moduleNameError", {
+                            name: m.var
+                        });
                     }
                     if (missingModules.indexOf(m.module) > -1) {
-                        return false;
+                        return RED._("node-red:function.error.missing-module", {
+                            module: m.module
+                        });
                     }
                     if (invalidModuleVNames.indexOf(m.var) !== -1){
-                        return false;
+                        return RED._("node-red:function.error.moduleNameError", {
+                            name: m.var
+                        });
                     }
                 }
                 return true;
@@ -399,11 +413,19 @@
                     $("#func-tabs-content").children().hide();
                     $("#" + tab.id).show();
                     let editor = $("#" + tab.id).find('.monaco-editor').first();
-                   	if(editor.length) {
+                    if(editor.length) {
                         if(that.editor.nodered && that.editor.type == "monaco") {
                             that.editor.nodered.refreshModuleLibs(getLibsList());
                         }
                         RED.tray.resize();
+                        //auto focus editor on tab switch
+                        if (that.initEditor.getDomNode() == editor[0]) {
+                            that.initEditor.focus();
+                        } else if (that.editor.getDomNode() == editor[0]) {
+                            that.editor.focus();
+                        } else if (that.finalizeEditor.getDomNode() == editor[0]) {
+                            that.finalizeEditor.focus();
+                        }
                     }
                 }
             });
@@ -438,11 +460,13 @@
                 }
             });
 
-            var buildEditor = function(id, value, defaultValue, extraLibs) {
+            var buildEditor = function(id, stateId, focus, value, defaultValue, extraLibs) {
                 var editor = RED.editor.createEditor({
                     id: id,
                     mode: 'ace/mode/nrjavascript',
                     value: value || defaultValue || "",
+                    stateId: stateId,
+                    focus: true,
                     globals: {
                         msg:true,
                         context:true,
@@ -462,11 +486,12 @@
                 if (defaultValue && value === "") {
                     editor.moveCursorTo(defaultValue.split("\n").length - 1, 0);
                 }
+                editor.__stateId = stateId;
                 return editor;
             }
-            this.initEditor = buildEditor('node-input-init-editor',$("#node-input-initialize").val(),RED._("node-red:function.text.initialize"))
-            this.editor = buildEditor('node-input-func-editor',$("#node-input-func").val(), undefined, that.libs || [])
-            this.finalizeEditor = buildEditor('node-input-finalize-editor',$("#node-input-finalize").val(),RED._("node-red:function.text.finalize"))
+            this.initEditor = buildEditor('node-input-init-editor', this.id + "/" + "initEditor", false, $("#node-input-initialize").val(), RED._("node-red:function.text.initialize"))
+            this.editor = buildEditor('node-input-func-editor', this.id + "/" + "editor", true, $("#node-input-func").val(), undefined, that.libs || [])
+            this.finalizeEditor = buildEditor('node-input-finalize-editor', this.id + "/" + "finalizeEditor", false, $("#node-input-finalize").val(), RED._("node-red:function.text.finalize"))
 
             RED.library.create({
                 url:"functions", // where to get the data from
@@ -505,28 +530,33 @@
                 ],
                 ext:"js"
             });
-            this.editor.focus();
-
 
             var expandButtonClickHandler = function(editor) {
-                return function(e) {
+                return function (e) {
                     e.preventDefault();
                     var value = editor.getValue();
+                    editor.saveView(`inside function-expandButtonClickHandler ${editor.__stateId}`);
                     var extraLibs = that.libs || [];
                     RED.editor.editJavaScript({
                         value: value,
                         width: "Infinity",
-                        cursor: editor.getCursorPosition(),
+                        stateId: editor.__stateId,
                         mode: "ace/mode/nrjavascript",
-                        complete: function(v,cursor) {
+                        focus: true,
+                        cancel: function () {
+                            setTimeout(function () {
+                                editor.focus();
+                            }, 250);
+                        },
+                        complete: function (v, cursor) {
                             editor.setValue(v, -1);
-                            editor.gotoLine(cursor.row+1,cursor.column,false);
-                            setTimeout(function() {
+                            setTimeout(function () {
+                                editor.restoreView();
                                 editor.focus();
-                            },300);
+                            }, 250);
                         },
                         extraLibs: extraLibs
-                    })
+                    });
                 }
             }
             $("#node-init-expand-js").on("click", expandButtonClickHandler(this.initEditor));
@@ -605,6 +635,12 @@
             this.finalizeEditor.resize();
 
             $("#node-input-libs-container").css("height", (height - 192)+"px");
+        },
+        onadd: function() {
+            if (this.name === '_DEFAULT_') {
+                this.name = ''
+                RED.actions.invoke("core:generate-node-names", this)
+            }
         }
     });
 })();

package/core/function/10-switch.html

@@ -163,7 +163,9 @@
         category: 'function',
         defaults: {
             name: {value:""},
-            property: {value:"payload", required:true, validate: RED.validators.typedInput("propertyType")},
+            property: {value:"payload", required:true,
+                       label:RED._("node-red:common.label.payload"),
+                       validate: RED.validators.typedInput("propertyType", false)},
             propertyType: { value:"msg" },
             rules: {value:[{t:"eq", v:"", vt:"str"}]},
             checkall: {value:"true", required:true},

package/core/function/10-switch.js

@@ -55,6 +55,7 @@ module.exports = function(RED) {
                 catch(e) { return false;}
             }
             else if (b === "null") { return a === null; }
+            else if (b === "number") { return typeof a === b && !isNaN(a) }
             else { return typeof a === b && !Array.isArray(a) && !Buffer.isBuffer(a) && a !== null; }
         },
         'head': function(a, b, c, d, parts) {

package/core/function/15-change.html

@@ -19,38 +19,66 @@
 
 <script type="text/javascript">
 (function() {
-    function validateProperty(v,vt) {
+    function isInvalidProperty(v,vt) {
         if (/msg|flow|global/.test(vt)) {
             if (!RED.utils.validatePropertyExpression(v)) {
-                return false;
+                return RED._("node-red:change.errors.invalid-prop", {
+                    property: v
+                });
             }
         } else if (vt === "jsonata") {
-            try{jsonata(v);}catch(e){return false;}
+            try{ jsonata(v); } catch(e) {
+                return RED._("node-red:change.errors.invalid-expr", {
+                    error: e.message
+                });
+            }
         } else if (vt === "json") {
-            try{JSON.parse(v);}catch(e){return false;}
+            try{ JSON.parse(v); } catch(e) {
+                return RED._("node-red:change.errors.invalid-json-data", {
+                    error: e.message
+                });
+            }
         }
-        return true;
+        return false;
     }
+
     RED.nodes.registerType('change', {
         color: "#E2D96E",
         category: 'function',
         defaults: {
             name: {value:""},
-            rules:{value:[{t:"set",p:"payload",pt:"msg",to:"",tot:"str"}],validate: function(rules) {
+            rules:{value:[{t:"set",p:"payload",pt:"msg",to:"",tot:"str"}],validate: function(rules, opt) {
+                var msg;
                 if (!rules || rules.length === 0) { return true }
                 for (var i=0;i<rules.length;i++) {
                     var r = rules[i];
                     if (r.t === 'set') {
-                        if (!validateProperty(r.p,r.pt) || !validateProperty(r.to,r.tot)) {
-                            return false;
+                        if (msg = isInvalidProperty(r.p,r.pt)) {
+                            return msg;
+                        }
+                        if (msg = isInvalidProperty(r.to,r.tot)) {
+                            return msg;
                         }
                     } else if (r.t === 'change') {
-                        if (!validateProperty(r.p,r.pt) || !validateProperty(r.from,r.fromt) || !validateProperty(r.to,r.tot)) {
-                            return false;
+                        if (msg = isInvalidProperty(r.p,r.pt)) {
+                            return msg;
+                        }
+                        if(msg = isInvalidProperty(r.from,r.fromt)) {
+                            return msg;
+                        }
+                        if(msg = isInvalidProperty(r.to,r.tot)) {
+                            return msg;
+                        }
+                    } else if (r.t === 'delete') {
+                        if (msg = isInvalidProperty(r.p,r.pt)) {
+                            return msg;
                         }
                     } else if (r.t === 'move') {
-                        if (!validateProperty(r.p,r.pt)) {
-                            return false;
+                        if (msg = isInvalidProperty(r.p,r.pt)) {
+                            return msg;
+                        }
+                        if (msg = isInvalidProperty(r.to,r.tot)) {
+                            return msg;
                         }
                     }
                 }

package/core/function/16-range.html

@@ -41,13 +41,22 @@
         color: "#E2D96E",
         category: 'function',
         defaults: {
-            minin: {value:"",required:true,validate:RED.validators.number()},
-            maxin: {value:"",required:true,validate:RED.validators.number()},
-            minout: {value:"",required:true,validate:RED.validators.number()},
-            maxout: {value:"",required:true,validate:RED.validators.number()},
+            minin: {value:"", required: true,
+                    label:RED._("node-red:range.label.minin"),
+                    validate:RED.validators.number(false)},
+            maxin: {value:"", required: true,
+                    label:RED._("node-red:range.label.maxin"),
+                    validate:RED.validators.number(false)},
+            minout: {value:"", required:true,
+                     label:RED._("node-red:range.label.minout"),
+                     validate:RED.validators.number(false)},
+            maxout: {value:"", required:true,
+                     label:RED._("node-red:range.label.maxout"),
+                     validate:RED.validators.number(false)},
             action: {value:"scale"},
             round: {value:false},
-            property: {value:"payload",required:true},
+            property: {value:"payload",required:true,
+                       label:RED._("node-red:common.label.property")},
             name: {value:""}
         },
         inputs: 1,

package/core/function/80-template.html

@@ -18,7 +18,7 @@
                 <option value="handlebars">mustache</option>
                 <option value="html">HTML</option>
                 <option value="json">JSON</option>
-                <option value="javascript">Javascript</option>
+                <option value="javascript">JavaScript</option>
                 <option value="css">CSS</option>
                 <option value="markdown">Markdown</option>
                 <option value="python">Python</option>
@@ -56,7 +56,9 @@
         category: 'function',
         defaults: {
             name: {value:""},
-            field: {value:"payload", validate:RED.validators.typedInput("fieldType")},
+            field: {value:"payload",
+                    label:"payload",
+                    validate:RED.validators.typedInput("fieldType", false)},
             fieldType: {value:"msg"},
             format: {value:"handlebars"},
             syntax: {value:"mustache"},
@@ -73,7 +75,8 @@
             return this.name?"node_label_italic":"";
         },
         oneditprepare: function() {
-            var that = this;
+            const that = this;
+            const stateId = RED.editor.generateViewStateId("node", this, "");
             if (!this.field) {
                 this.field = 'payload';
                 $("#node-input-field").val("payload");
@@ -90,10 +93,10 @@
                 types: ['msg','flow','global'],
                 typeField: $("#node-input-fieldType")
             });
-
             this.editor = RED.editor.createEditor({
                 id: 'node-input-template-editor',
                 mode: 'ace/mode/html',
+                stateId: stateId,
                 value: $("#node-input-template").val()
             });
             RED.library.create({
@@ -103,7 +106,6 @@
                 fields:['name','format','output','syntax'],
                 ext: "txt"
             });
-            this.editor.focus();
 
             $("#node-input-format").on("change", function() {
                 var mod = "ace/mode/"+$("#node-input-format").val();
@@ -113,20 +115,22 @@
                 });
             });
             RED.popover.tooltip($("#node-template-expand-editor"), RED._("node-red:common.label.expand"));
-            $("#node-template-expand-editor").on("click", function(e) {
+            $("#node-template-expand-editor").on("click", function (e) {
                 e.preventDefault();
-                var value = that.editor.getValue();
+                const value = that.editor.getValue();
+                that.editor.saveView();
                 RED.editor.editText({
                     mode: $("#node-input-format").val(),
                     value: value,
+                    stateId: stateId,
                     width: "Infinity",
-                    cursor: that.editor.getCursorPosition(),
-                    complete: function(v,cursor) {
+                    focus: true,
+                    complete: function (v, cursor) {
                         that.editor.setValue(v, -1);
-                        that.editor.gotoLine(cursor.row+1,cursor.column,false);
-                        setTimeout(function() {
+                        setTimeout(function () {
+                            that.editor.restoreView();
                             that.editor.focus();
-                        },300);
+                        }, 250);
                     }
                 })
             })