@node-red/editor-client 4.0.0-beta.1 → 4.0.0-beta.2

package/public/red/red.js

@@ -116,6 +116,7 @@ var RED = (function() {
             cache: false,
             url: 'plugins',
             success: function(data) {
+                RED.plugins.setPluginList(data);
                 loader.reportProgress(RED._("event.loadPlugins"), 13)
                 RED.i18n.loadPluginCatalogs(function() {
                     loadPlugins(function() {
@@ -625,6 +626,41 @@ var RED = (function() {
                 RED.view.redrawStatus(node);
             }
         });
+        RED.comms.subscribe("notification/plugin/#",function(topic,msg) {
+            if (topic == "notification/plugin/added") {
+                RED.settings.refreshSettings(function(err, data) {
+                    let addedPlugins = [];
+                    msg.forEach(function(m) {
+                        let id = m.id;
+                        RED.plugins.addPlugin(m);
+
+                        m.plugins.forEach((p) => {
+                            addedPlugins.push(p.id);
+                        })
+
+                        RED.i18n.loadNodeCatalog(id, function() {
+                            var lang = localStorage.getItem("editor-language")||RED.i18n.detectLanguage();
+                            $.ajax({
+                                headers: {
+                                    "Accept":"text/html",
+                                    "Accept-Language": lang
+                                },
+                                cache: false,
+                                url: 'plugins/'+id,
+                                success: function(data) {
+                                    appendPluginConfig(data);
+                                }
+                            });
+                        });
+                    });
+                    if (addedPlugins.length) {
+                        let pluginList = "<ul><li>"+addedPlugins.map(RED.utils.sanitize).join("</li><li>")+"</li></ul>";
+                        // ToDo: Adapt notification (node -> plugin)
+                        RED.notify(RED._("palette.event.nodeAdded", {count:addedPlugins.length})+pluginList,"success");
+                    }
+                })
+            }
+        });
 
         let pendingNodeRemovedNotifications = []
         let pendingNodeRemovedTimeout
@@ -894,6 +930,10 @@ var RED = (function() {
 
         RED.nodes.init();
         RED.runtime.init()
+
+        if (RED.settings.theme("multiplayer.enabled",false)) {
+            RED.multiplayer.init()
+        }
         RED.comms.connect();
 
         $("#red-ui-main-container").show();
@@ -1812,6 +1852,7 @@ RED.user = (function() {
     }
 
     function logout() {
+        RED.events.emit('logout')
         var tokens = RED.settings.get("auth-tokens");
         var token = tokens?tokens.access_token:"";
         $.ajax({
@@ -1850,6 +1891,7 @@ RED.user = (function() {
                     });
                 }
             });
+            $('<i class="fa fa-user"></i>').appendTo("#red-ui-header-button-user");
         } else {
             RED.menu.addItem("red-ui-header-button-user",{
                 id:"usermenu-item-username",
@@ -1862,6 +1904,15 @@ RED.user = (function() {
                     RED.user.logout();
                 }
             });
+            const userMenu = $("#red-ui-header-button-user")
+            userMenu.empty()
+            if (RED.settings.user.image) {
+                $('<span class="user-profile"></span>').css({
+                    backgroundImage: "url("+RED.settings.user.image+")",
+                }).appendTo(userMenu);
+            } else {
+                $('<i class="fa fa-user"></i>').appendTo(userMenu);
+            }
         }
 
     }
@@ -1872,14 +1923,6 @@ RED.user = (function() {
 
                 var userMenu = $('<li><a id="red-ui-header-button-user" class="button hide" href="#"></a></li>')
                     .prependTo(".red-ui-header-toolbar");
-                if (RED.settings.user.image) {
-                    $('<span class="user-profile"></span>').css({
-                        backgroundImage: "url("+RED.settings.user.image+")",
-                    }).appendTo(userMenu.find("a"));
-                } else {
-                    $('<i class="fa fa-user"></i>').appendTo(userMenu.find("a"));
-                }
-
                 RED.menu.init({id:"red-ui-header-button-user",
                     options: []
                 });
@@ -1979,6 +2022,15 @@ RED.comms = (function() {
     var reconnectAttempts = 0;
     var active = false;
 
+    RED.events.on('login', function(username) {
+        // User has logged in
+        // Need to upgrade the connection to be authenticated
+        if (ws && ws.readyState == 1) {
+            const auth_tokens = RED.settings.get("auth-tokens");
+            ws.send(JSON.stringify({auth:auth_tokens.access_token}))
+        }
+    })
+
     function connectWS() {
         active = true;
         var wspath;
@@ -2009,6 +2061,7 @@ RED.comms = (function() {
                     ws.send(JSON.stringify({subscribe:t}));
                 }
             }
+            emit('connect')
         }
 
         ws = new WebSocket(wspath);
@@ -2133,10 +2186,54 @@ RED.comms = (function() {
         }
     }
 
+    function send(topic, msg) {
+        if (ws && ws.readyState == 1) {
+            ws.send(JSON.stringify({
+                topic,
+                data: msg
+            }))
+        }
+    }
+
+    const eventHandlers = {};
+    function on(evt,func) {
+        eventHandlers[evt] = eventHandlers[evt]||[];
+        eventHandlers[evt].push(func);
+    }
+    function off(evt,func) {
+        const handler = eventHandlers[evt];
+        if (handler) {
+            for (let i=0;i<handler.length;i++) {
+                if (handler[i] === func) {
+                    handler.splice(i,1);
+                    return;
+                }
+            }
+        }
+    }
+    function emit() {
+        const evt = arguments[0]
+        const args = Array.prototype.slice.call(arguments,1);
+        if (eventHandlers[evt]) {
+            let cpyHandlers = [...eventHandlers[evt]];
+            for (let i=0;i<cpyHandlers.length;i++) {
+                try {
+                    cpyHandlers[i].apply(null, args);
+                } catch(err) {
+                    console.warn("RED.comms.emit error: ["+evt+"] "+(err.toString()));
+                    console.warn(err);
+                }
+            }
+        }
+    }
+
     return {
         connect: connectWS,
         subscribe: subscribe,
-        unsubscribe:unsubscribe
+        unsubscribe:unsubscribe,
+        on,
+        off,
+        send
     }
 })();
 ;RED.runtime = (function() {
@@ -2175,6 +2272,223 @@ RED.comms = (function() {
         }
     }
 })()
+;RED.multiplayer = (function () {
+
+    // sessionId - used to identify sessions across websocket reconnects
+    let sessionId
+
+    let headerWidget
+    // Map of session id to { session:'', user:{}, location:{}}
+    let connections = {}
+    // Map of username to { user:{}, connections:[] }
+    let users = {}
+
+    function addUserConnection (connection) {
+        if (connections[connection.session]) {
+            // This is an existing connection that has been authenticated
+            const existingConnection = connections[connection.session]
+            if (existingConnection.user.username !== connection.user.username) {
+                removeUserButton(users[existingConnection.user.username])
+            }
+        }
+        connections[connection.session] = connection
+        const user = users[connection.user.username] = users[connection.user.username] || {
+            user: connection.user,
+            connections: []
+        }
+        connection.location = connection.location || {}
+        user.connections.push(connection)
+
+        if (connection.user.username === RED.settings.user?.username ||
+            connection.session === sessionId
+        ) {
+            // This is the current user - do not add a extra button for them
+        } else {
+            if (user.connections.length === 1) {
+                if (user.button) {
+                    clearTimeout(user.inactiveTimeout)
+                    clearTimeout(user.removeTimeout)
+                    user.button.removeClass('inactive')
+                } else {
+                    addUserButton(user)
+                }
+            }
+        }
+    }
+
+    function removeUserConnection (session, isDisconnected) {
+        const connection = connections[session]
+        delete connections[session]
+        const user = users[connection.user.username]
+        const i = user.connections.indexOf(connection)
+        user.connections.splice(i, 1)
+        if (isDisconnected) {
+            removeUserButton(user)
+        } else {
+            if (user.connections.length === 0) {
+                // Give the user 5s to reconnect before marking inactive
+                user.inactiveTimeout = setTimeout(() => {
+                    user.button.addClass('inactive')
+                    // Give the user further 20 seconds to reconnect before removing them
+                    // from the user toolbar entirely
+                    user.removeTimeout = setTimeout(() => {
+                        removeUserButton(user)
+                    }, 20000)
+                }, 5000)
+            }
+        }
+    }
+
+    function addUserButton (user) {
+        user.button = $('<li class="red-ui-multiplayer-user"><button type="button" class="red-ui-multiplayer-user-icon" href="#"></button></li>')
+            .attr('data-username', user.user.username)
+            .prependTo("#red-ui-multiplayer-user-list");
+        var button = user.button.find("button")
+        button.on('click', function () {
+            RED.popover.create({
+                target:button,
+                trigger: 'modal',
+                interactive: true,
+                width: "250px",
+                direction: 'bottom',
+                content: () => { 
+                    const content = $('<div>')
+                    $('<div style="text-align: center">').text(user.user.username).appendTo(content)
+
+                    const location = user.connections[0].location
+                    if (location.workspace) {
+                        const ws = RED.nodes.workspace(location.workspace) || RED.nodes.subflow(location.workspace)
+                        if (ws) {
+                            $('<div>').text(`${ws.type}: ${ws.label||ws.name||ws.id}`).appendTo(content)
+                        } else {
+                            $('<div>').text(`tab: unknown`).appendTo(content)
+                        }
+                    }
+                    if (location.node) {
+                        const node = RED.nodes.node(location.node)
+                        if (node) {
+                            $('<div>').text(`node: ${node.id}`).appendTo(content)
+                        } else {
+                            $('<div>').text(`node: unknown`).appendTo(content)
+                        }
+                    }
+                    return content
+                },
+            }).open()
+        })
+        if (!user.user.image) {
+            $('<i class="fa fa-user"></i>').appendTo(button);
+        } else {
+            $('<span class="user-profile"></span>').css({
+                backgroundImage: "url("+user.user.image+")",
+            }).appendTo(button);
+        }
+    }
+
+    function getLocation () {
+        const location = {
+            workspace: RED.workspaces.active()
+        }
+        const editStack = RED.editor.getEditStack()
+        for (let i = editStack.length - 1; i >= 0; i--) {
+            if (editStack[i].id) {
+                location.node = editStack[i].id
+                break
+            }
+        }
+        return location
+    }
+    function updateLocation () {
+        const location = getLocation()
+        if (location.workspace !== 0) {
+            log('send', 'multiplayer/location', location)
+            RED.comms.send('multiplayer/location', location)
+        }
+    }
+
+    function removeUserButton (user) {
+        user.button.remove()
+        delete user.button
+    }
+
+    function updateUserLocation (data) {
+        connections[data.session].location = data
+        delete data.session
+    }
+    return {
+        init: function () {
+            
+
+            sessionId = RED.settings.getLocal('multiplayer:sessionId')
+            if (!sessionId) {
+                sessionId = RED.nodes.id()
+                RED.settings.setLocal('multiplayer:sessionId', sessionId)
+            }
+            
+            headerWidget = $('<li><ul id="red-ui-multiplayer-user-list"></ul></li>').prependTo('.red-ui-header-toolbar')
+
+            RED.comms.on('connect', () => {
+                const location = getLocation()
+                const connectInfo = {
+                    session: sessionId
+                }
+                if (location.workspace !== 0) {
+                    connectInfo.location = location
+                }
+                RED.comms.send('multiplayer/connect', connectInfo)
+            })
+            RED.comms.subscribe('multiplayer/#', (topic, msg) => {
+                log('recv', topic, msg)
+                if (topic === 'multiplayer/init') {
+                    // We have just reconnected, runtime has sent state to
+                    // initialise the world
+                    connections = {}
+                    users = {}
+                    $('#red-ui-multiplayer-user-list').empty()
+
+                    msg.forEach(connection => {
+                        addUserConnection(connection)
+                    })
+                } else if (topic === 'multiplayer/connection-added') {
+                    addUserConnection(msg)
+                } else if (topic === 'multiplayer/connection-removed') {
+                    removeUserConnection(msg.session, msg.disconnected)
+                } else if (topic === 'multiplayer/location') {
+                    updateUserLocation(msg)
+                }
+            })
+
+            RED.events.on('workspace:change', (event) => {
+                updateLocation()
+            })
+            RED.events.on('editor:open', () => {
+                updateLocation()
+            })
+            RED.events.on('editor:close', () => {
+                updateLocation()
+            })
+            RED.events.on('editor:change', () => {
+                updateLocation()
+            })
+            RED.events.on('login', () => {
+                updateLocation()
+            })
+            RED.events.on('logout', () => {
+                const disconnectInfo = {
+                    session: sessionId
+                }
+                RED.comms.send('multiplayer/disconnect', disconnectInfo)
+                RED.settings.removeLocal('multiplayer:sessionId')
+            })
+        }
+    }
+
+    function log() {
+        if (RED.multiplayer.DEBUG) {
+            console.log('[multiplayer]', ...arguments)
+        }
+    }
+})();
 ;/**
  * Copyright JS Foundation and other contributors, http://js.foundation
  *
@@ -3672,6 +3986,7 @@ RED.state = {
 ;RED.plugins = (function() {
     var plugins = {};
     var pluginsByType = {};
+    var moduleList = {};
 
     function registerPlugin(id,definition) {
         plugins[id] = definition;
@@ -3709,10 +4024,44 @@ RED.state = {
     function getPluginsByType(type) {
         return pluginsByType[type] || [];
     }
+
+    function setPluginList(list) {
+        for(let i=0;i<list.length;i++) {
+            let p = list[i];
+            addPlugin(p);
+        }
+    }
+
+    function addPlugin(p) {
+
+        moduleList[p.module] = moduleList[p.module] || {
+            name:p.module,
+            version:p.version,
+            local:p.local,
+            sets:{},
+            plugin: true,
+            id: p.id
+        };
+        if (p.pending_version) {
+            moduleList[p.module].pending_version = p.pending_version;
+        }
+        moduleList[p.module].sets[p.name] = p;
+
+        RED.events.emit("registry:plugin-module-added",p.module);
+    }
+
+    function getModule(module) {
+        return moduleList[module];
+    }
+
     return {
         registerPlugin: registerPlugin,
         getPlugin: getPlugin,
-        getPluginsByType: getPluginsByType
+        getPluginsByType: getPluginsByType,
+
+        setPluginList: setPluginList,
+        addPlugin: addPlugin,
+        getModule: getModule
     }
 })();
 ;/**
@@ -3866,6 +4215,8 @@ RED.nodes = (function() {
             },
             removeNodeSet: function(id) {
                 var ns = nodeSets[id];
+                if (!ns) { return {} }
+
                 for (var j=0;j<ns.types.length;j++) {
                     delete typeToId[ns.types[j]];
                 }
@@ -4289,12 +4640,16 @@ RED.nodes = (function() {
              * @param {String} z tab id
              */
             checkTabState: function (z) {
-                const ws = workspaces[z]
+                const ws = workspaces[z] || subflows[z]
                 if (ws) {
                     const contentsChanged = tabDirtyMap[z].size > 0 || tabDeletedNodesMap[z].size > 0
                     if (Boolean(ws.contentsChanged) !== contentsChanged) {
                         ws.contentsChanged = contentsChanged
-                        RED.events.emit("flows:change", ws);
+                        if (ws.type === 'tab') {
+                            RED.events.emit("flows:change", ws);
+                        } else {
+                            RED.events.emit("subflows:change", ws);
+                        }
                     }
                 }
             }
@@ -4767,7 +5122,22 @@ RED.nodes = (function() {
         RED.nodes.registerType("subflow:"+sf.id, {
             defaults:{
                 name:{value:""},
-                env:{value:[]}
+                env:{value:[], validate: function(value) {
+                    const errors = []
+                    if (value) {
+                        value.forEach(env => {
+                            const r = RED.utils.validateTypedProperty(env.value, env.type)
+                            if (r !== true) {
+                                errors.push(env.name+': '+r)
+                            }
+                        })
+                    }
+                    if (errors.length === 0) {
+                        return true
+                    } else {
+                        return errors
+                    }
+                }}
             },
             icon: function() { return sf.icon||"subflow.svg" },
             category: sf.category || "subflows",
@@ -12309,7 +12679,7 @@ RED.popover = (function() {
                         closePopup(true);
                     });
                 }
-                if (trigger === 'hover' && options.interactive) {
+                if (/*trigger === 'hover' && */options.interactive) {
                     div.on('mouseenter', function(e) {
                         clearTimeout(timer);
                         active = true;
@@ -19920,10 +20290,6 @@ RED.keyboard = (function() {
     }
 
     function init(done) {
-        if (!RED.user.hasPermission("settings.write")) {
-            RED.notify(RED._("user.errors.settings"),"error");
-            return;
-        }
         RED.userSettings.add({
             id:'envvar',
             title: RED._("env-var.environment"),
@@ -20447,6 +20813,11 @@ RED.workspaces = (function() {
         createWorkspaceTabs();
         RED.events.on("sidebar:resize",workspace_tabs.resize);
 
+        RED.events.on("workspace:clear", () => {
+            // Reset the index used to generate new flow names
+            workspaceIndex = 0
+        })
+
         RED.actions.add("core:show-next-tab",function() {
             var oldActive = activeWorkspace;
             workspace_tabs.nextTab();
@@ -20613,6 +20984,9 @@ RED.workspaces = (function() {
         RED.events.on("flows:change", (ws) => {
             $("#red-ui-tab-"+(ws.id.replace(".","-"))).toggleClass('red-ui-workspace-changed',!!(ws.contentsChanged || ws.changed || ws.added));
         })
+        RED.events.on("subflows:change", (ws) => {
+            $("#red-ui-tab-"+(ws.id.replace(".","-"))).toggleClass('red-ui-workspace-changed',!!(ws.contentsChanged || ws.changed || ws.added));
+        })
 
         hideWorkspace();
     }
@@ -29427,6 +29801,10 @@ RED.palette = (function() {
     var categoryContainers = {};
     var sidebarControls;
 
+    let paletteState = { filter: "", collapsed: [] };
+
+    let filterRefreshTimeout
+
     function createCategory(originalCategory,rootCategory,category,ns) {
         if ($("#red-ui-palette-base-category-"+rootCategory).length === 0) {
             createCategoryContainer(originalCategory,rootCategory, ns+":palette.label."+rootCategory);
@@ -29452,20 +29830,57 @@ RED.palette = (function() {
         catDiv.data('label',label);
         categoryContainers[category] = {
             container: catDiv,
-            close: function() {
+            hide: function (instant) {
+                if (instant) {
+                    catDiv.hide()
+                } else {
+                    catDiv.slideUp()
+                }
+            },
+            show: function () {
+                catDiv.show()
+            },
+            isOpen: function () {
+                return !!catDiv.hasClass("red-ui-palette-open")
+            },
+            getNodeCount: function (visibleOnly) {
+                const nodes = catDiv.find(".red-ui-palette-node")
+                if (visibleOnly) {
+                    return nodes.filter(function() { return $(this).css('display') !== 'none'}).length
+                } else {
+                    return nodes.length
+                }
+            },
+            close: function(instant, skipSaveState) {
                 catDiv.removeClass("red-ui-palette-open");
                 catDiv.addClass("red-ui-palette-closed");
-                $("#red-ui-palette-base-category-"+category).slideUp();
+                if (instant) {
+                    $("#red-ui-palette-base-category-"+category).hide();
+                } else {
+                    $("#red-ui-palette-base-category-"+category).slideUp();
+                }
                 $("#red-ui-palette-header-"+category+" i").removeClass("expanded");
+                if (!skipSaveState) {
+                    if (!paletteState.collapsed.includes(category)) {
+                        paletteState.collapsed.push(category);
+                        savePaletteState();
+                    }
+                }
             },
-            open: function() {
+            open: function(skipSaveState) {
                 catDiv.addClass("red-ui-palette-open");
                 catDiv.removeClass("red-ui-palette-closed");
                 $("#red-ui-palette-base-category-"+category).slideDown();
                 $("#red-ui-palette-header-"+category+" i").addClass("expanded");
+                if (!skipSaveState) {
+                    if (paletteState.collapsed.includes(category)) {
+                        paletteState.collapsed.splice(paletteState.collapsed.indexOf(category), 1);
+                        savePaletteState();
+                    }
+                }
             },
             toggle: function() {
-                if (catDiv.hasClass("red-ui-palette-open")) {
+                if (categoryContainers[category].isOpen()) {
                     categoryContainers[category].close();
                 } else {
                     categoryContainers[category].open();
@@ -29807,8 +30222,16 @@ RED.palette = (function() {
 
             var categoryNode = $("#red-ui-palette-container-"+rootCategory);
             if (categoryNode.find(".red-ui-palette-node").length === 1) {
-                categoryContainers[rootCategory].open();
+                if (!paletteState?.collapsed?.includes(rootCategory)) {
+                    categoryContainers[rootCategory].open();
+                } else {
+                    categoryContainers[rootCategory].close(true);
+                }
             }
+            clearTimeout(filterRefreshTimeout)
+            filterRefreshTimeout = setTimeout(() => {
+                refreshFilter()
+            }, 200)
 
         }
     }
@@ -29908,7 +30331,8 @@ RED.palette = (function() {
         paletteNode.css("backgroundColor", sf.color);
     }
 
-    function filterChange(val) {
+    function refreshFilter() {
+        const val = $("#red-ui-palette-search input").val()
         var re = new RegExp(val.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'),'i');
         $("#red-ui-palette-container .red-ui-palette-node").each(function(i,el) {
             var currentLabel = $(el).attr("data-palette-label");
@@ -29920,16 +30344,26 @@ RED.palette = (function() {
             }
         });
 
-        for (var category in categoryContainers) {
+        for (let category in categoryContainers) {
             if (categoryContainers.hasOwnProperty(category)) {
-                if (categoryContainers[category].container
-                        .find(".red-ui-palette-node")
-                        .filter(function() { return $(this).css('display') !== 'none'}).length === 0) {
-                    categoryContainers[category].close();
-                    categoryContainers[category].container.slideUp();
+                const categorySection = categoryContainers[category]
+                if (categorySection.getNodeCount(true) === 0) {
+                    categorySection.hide()
                 } else {
-                    categoryContainers[category].open();
-                    categoryContainers[category].container.show();
+                    categorySection.show()
+                    if (val) {
+                        // There is a filter being applied and it has matched
+                        // something in this category - show the contents
+                        categorySection.open(true)
+                    } else {
+                        // No filter. Only show the category if it isn't in lastState
+                        if (!paletteState.collapsed.includes(category)) {
+                            categorySection.open(true)
+                        } else if (categorySection.isOpen()) {
+                            // This section should be collapsed but isn't - so make it so
+                            categorySection.close(true, true)
+                        }
+                    }
                 }
             }
         }
@@ -29945,6 +30379,9 @@ RED.palette = (function() {
 
         $("#red-ui-palette > .red-ui-palette-spinner").show();
 
+        RED.events.on('logout', function () {
+            RED.settings.removeLocal('palette-state')
+        })
 
         RED.events.on('registry:node-type-added', function(nodeType) {
             var def = RED.nodes.getType(nodeType);
@@ -29988,14 +30425,14 @@ RED.palette = (function() {
 
         RED.events.on("subflows:change",refreshSubflow);
 
-
-
         $("#red-ui-palette-search input").searchBox({
             delay: 100,
             change: function() {
-                filterChange($(this).val());
+                refreshFilter();
+                paletteState.filter = $(this).val();
+                savePaletteState();
             }
-        })
+        });
 
         sidebarControls = $('<div class="red-ui-sidebar-control-left"><i class="fa fa-chevron-left"></i></div>').appendTo($("#red-ui-palette"));
         RED.popover.tooltip(sidebarControls,RED._("keyboard.togglePalette"),"core:toggle-palette");
@@ -30061,7 +30498,23 @@ RED.palette = (function() {
                 togglePalette(state);
             }
         });
+
+        try {
+            paletteState = JSON.parse(RED.settings.getLocal("palette-state") || '{"filter":"", "collapsed": []}');
+            if (paletteState.filter) {
+                // Apply the category filter
+                $("#red-ui-palette-search input").searchBox("value", paletteState.filter);
+            }
+        } catch (error) {
+            console.error("Unexpected error loading palette state from localStorage: ", error);
+        }
+        setTimeout(() => {
+            // Lazily tidy up any categories that haven't been reloaded
+            paletteState.collapsed = paletteState.collapsed.filter(category => !!categoryContainers[category])
+            savePaletteState()
+        }, 10000)
     }
+
     function togglePalette(state) {
         if (!state) {
             $("#red-ui-main-container").addClass("red-ui-palette-closed");
@@ -30081,6 +30534,15 @@ RED.palette = (function() {
         })
         return categories;
     }
+
+    function savePaletteState() {
+        try {
+            RED.settings.setLocal("palette-state", JSON.stringify(paletteState));
+        } catch (error) {
+            console.error("Unexpected error saving palette state to localStorage: ", error);
+        }
+    }
+
     return {
         init: init,
         add:addNodeType,
@@ -31570,8 +32032,10 @@ RED.sidebar.help = (function() {
 
     function refreshSubflow(sf) {
         var item = treeList.treeList('get',"node-type:subflow:"+sf.id);
-        item.subflowLabel = sf._def.label().toLowerCase();
-        item.treeList.replaceElement(getNodeLabel({_def:sf._def,type:sf._def.label()}));
+        if (item) {
+            item.subflowLabel = sf._def.label().toLowerCase();
+            item.treeList.replaceElement(getNodeLabel({_def:sf._def,type:sf._def.label()}));
+        }
     }
 
     function hideTOC() {
@@ -32938,86 +33402,106 @@ RED.palette.editor = (function() {
             var moduleInfo = nodeEntries[module].info;
             var nodeEntry = nodeEntries[module].elements;
             if (nodeEntry) {
-                var activeTypeCount = 0;
-                var typeCount = 0;
-                var errorCount = 0;
-                nodeEntry.errorList.empty();
-                nodeEntries[module].totalUseCount = 0;
-                nodeEntries[module].setUseCount = {};
-
-                for (var setName in moduleInfo.sets) {
-                    if (moduleInfo.sets.hasOwnProperty(setName)) {
-                        var inUseCount = 0;
-                        var set = moduleInfo.sets[setName];
-                        var setElements = nodeEntry.sets[setName];
-                        if (set.err) {
-                            errorCount++;
-                            var errMessage = set.err;
-                            if (set.err.message) {
-                                errMessage = set.err.message;
-                            } else if (set.err.code) {
-                                errMessage = set.err.code;
-                            }
-                            $("<li>").text(errMessage).appendTo(nodeEntry.errorList);
-                        }
-                        if (set.enabled) {
-                            activeTypeCount += set.types.length;
-                        }
-                        typeCount += set.types.length;
-                        for (var i=0;i<moduleInfo.sets[setName].types.length;i++) {
-                            var t = moduleInfo.sets[setName].types[i];
-                            inUseCount += (typesInUse[t]||0);
-                            var swatch = setElements.swatches[t];
-                            if (set.enabled) {
-                                var def = RED.nodes.getType(t);
-                                if (def && def.color) {
-                                    swatch.css({background:RED.utils.getNodeColor(t,def)});
-                                    swatch.css({border: "1px solid "+getContrastingBorder(swatch.css('backgroundColor'))})
-                                }
+                if (moduleInfo.plugin) {
+                    nodeEntry.enableButton.hide();
+                    nodeEntry.removeButton.show();
+
+                    let pluginCount = 0;
+                    for (let setName in moduleInfo.sets) {
+                        if (moduleInfo.sets.hasOwnProperty(setName)) {
+                            let set = moduleInfo.sets[setName];
+                            if (set.plugins) {
+                                pluginCount += set.plugins.length;
                             }
                         }
-                        nodeEntries[module].setUseCount[setName] = inUseCount;
-                        nodeEntries[module].totalUseCount += inUseCount;
+                    }
+                    
+                    nodeEntry.setCount.text(RED._('palette.editor.pluginCount',{count:pluginCount,label:pluginCount}));
 
-                        if (inUseCount > 0) {
-                            setElements.enableButton.text(RED._('palette.editor.inuse'));
-                            setElements.enableButton.addClass('disabled');
-                        } else {
-                            setElements.enableButton.removeClass('disabled');
+                } else {
+                    var activeTypeCount = 0;
+                    var typeCount = 0;
+                    var errorCount = 0;
+                    nodeEntry.errorList.empty();
+                    nodeEntries[module].totalUseCount = 0;
+                    nodeEntries[module].setUseCount = {};
+
+                    for (var setName in moduleInfo.sets) {
+                        if (moduleInfo.sets.hasOwnProperty(setName)) {
+                            var inUseCount = 0;
+                            const set = moduleInfo.sets[setName];
+                            const setElements = nodeEntry.sets[setName]
+
+                            if (set.err) {
+                                errorCount++;
+                                var errMessage = set.err;
+                                if (set.err.message) {
+                                    errMessage = set.err.message;
+                                } else if (set.err.code) {
+                                    errMessage = set.err.code;
+                                }
+                                $("<li>").text(errMessage).appendTo(nodeEntry.errorList);
+                            }
                             if (set.enabled) {
-                                setElements.enableButton.text(RED._('palette.editor.disable'));
-                            } else {
-                                setElements.enableButton.text(RED._('palette.editor.enable'));
+                                activeTypeCount += set.types.length;
+                            }
+                            typeCount += set.types.length;
+                            for (var i=0;i<moduleInfo.sets[setName].types.length;i++) {
+                                var t = moduleInfo.sets[setName].types[i];
+                                inUseCount += (typesInUse[t]||0);
+                                if (setElements && set.enabled) {
+                                    var def = RED.nodes.getType(t);
+                                    if (def && def.color) {
+                                        setElements.swatches[t].css({background:RED.utils.getNodeColor(t,def)});
+                                        setElements.swatches[t].css({border: "1px solid "+getContrastingBorder(setElements.swatches[t].css('backgroundColor'))})
+                                    }
+                                }
+                            }
+                            nodeEntries[module].setUseCount[setName] = inUseCount;
+                            nodeEntries[module].totalUseCount += inUseCount;
+
+                            if (setElements) {
+                                if (inUseCount > 0) {
+                                    setElements.enableButton.text(RED._('palette.editor.inuse'));
+                                    setElements.enableButton.addClass('disabled');
+                                } else {
+                                    setElements.enableButton.removeClass('disabled');
+                                    if (set.enabled) {
+                                        setElements.enableButton.text(RED._('palette.editor.disable'));
+                                    } else {
+                                        setElements.enableButton.text(RED._('palette.editor.enable'));
+                                    }
+                                }
+                                setElements.setRow.toggleClass("red-ui-palette-module-set-disabled",!set.enabled);
                             }
                         }
-                        setElements.setRow.toggleClass("red-ui-palette-module-set-disabled",!set.enabled);
                     }
-                }
 
-                if (errorCount === 0) {
-                    nodeEntry.errorRow.hide()
-                } else {
-                    nodeEntry.errorRow.show();
-                }
+                    if (errorCount === 0) {
+                        nodeEntry.errorRow.hide()
+                    } else {
+                        nodeEntry.errorRow.show();
+                    }
 
-                var nodeCount = (activeTypeCount === typeCount)?typeCount:activeTypeCount+" / "+typeCount;
-                nodeEntry.setCount.text(RED._('palette.editor.nodeCount',{count:typeCount,label:nodeCount}));
+                    var nodeCount = (activeTypeCount === typeCount)?typeCount:activeTypeCount+" / "+typeCount;
+                    nodeEntry.setCount.text(RED._('palette.editor.nodeCount',{count:typeCount,label:nodeCount}));
 
-                if (nodeEntries[module].totalUseCount > 0) {
-                    nodeEntry.enableButton.text(RED._('palette.editor.inuse'));
-                    nodeEntry.enableButton.addClass('disabled');
-                    nodeEntry.removeButton.hide();
-                } else {
-                    nodeEntry.enableButton.removeClass('disabled');
-                    if (moduleInfo.local) {
-                        nodeEntry.removeButton.css('display', 'inline-block');
-                    }
-                    if (activeTypeCount === 0) {
-                        nodeEntry.enableButton.text(RED._('palette.editor.enableall'));
+                    if (nodeEntries[module].totalUseCount > 0) {
+                        nodeEntry.enableButton.text(RED._('palette.editor.inuse'));
+                        nodeEntry.enableButton.addClass('disabled');
+                        nodeEntry.removeButton.hide();
                     } else {
-                        nodeEntry.enableButton.text(RED._('palette.editor.disableall'));
+                        nodeEntry.enableButton.removeClass('disabled');
+                        if (moduleInfo.local) {
+                            nodeEntry.removeButton.css('display', 'inline-block');
+                        }
+                        if (activeTypeCount === 0) {
+                            nodeEntry.enableButton.text(RED._('palette.editor.enableall'));
+                        } else {
+                            nodeEntry.enableButton.text(RED._('palette.editor.disableall'));
+                        }
+                        nodeEntry.container.toggleClass("disabled",(activeTypeCount === 0));
                     }
-                    nodeEntry.container.toggleClass("disabled",(activeTypeCount === 0));
                 }
             }
             if (moduleInfo.pending_version) {
@@ -33368,6 +33852,33 @@ RED.palette.editor = (function() {
                 }
             }
         })
+
+        RED.events.on("registry:plugin-module-added", function(module) {
+
+            if (!nodeEntries.hasOwnProperty(module)) {
+                nodeEntries[module] = {info:RED.plugins.getModule(module)};
+                var index = [module];
+                for (var s in nodeEntries[module].info.sets) {
+                    if (nodeEntries[module].info.sets.hasOwnProperty(s)) {
+                        index.push(s);
+                        index = index.concat(nodeEntries[module].info.sets[s].types)
+                    }
+                }
+                nodeEntries[module].index = index.join(",").toLowerCase();
+                nodeList.editableList('addItem', nodeEntries[module]);
+            } else {
+                _refreshNodeModule(module);
+            }
+
+            for (var i=0;i<filteredList.length;i++) {
+                if (filteredList[i].info.id === module) {
+                    var installButton = filteredList[i].elements.installButton;
+                    installButton.addClass('disabled');
+                    installButton.text(RED._('palette.editor.installed'));
+                    break;
+                }
+            }
+        });
     }
 
     var settingsPane;
@@ -33494,6 +34005,7 @@ RED.palette.editor = (function() {
                         errorRow: errorRow,
                         errorList: errorList,
                         setCount: setCount,
+                        setButton: setButton,
                         container: container,
                         shade: shade,
                         versionSpan: versionSpan,
@@ -33504,49 +34016,88 @@ RED.palette.editor = (function() {
                         if (container.hasClass('expanded')) {
                             container.removeClass('expanded');
                             contentRow.slideUp();
+                            setTimeout(() => {
+                                contentRow.empty()
+                            }, 200)
+                            object.elements.sets = {}
                         } else {
                             container.addClass('expanded');
+                            populateSetList()
                             contentRow.slideDown();
                         }
                     })
-
-                    var setList = Object.keys(entry.sets)
-                    setList.sort(function(A,B) {
-                        return A.toLowerCase().localeCompare(B.toLowerCase());
-                    });
-                    setList.forEach(function(setName) {
-                        var set = entry.sets[setName];
-                        var setRow = $('<div>',{class:"red-ui-palette-module-set"}).appendTo(contentRow);
-                        var buttonGroup = $('<div>',{class:"red-ui-palette-module-set-button-group"}).appendTo(setRow);
-                        var typeSwatches = {};
-                        set.types.forEach(function(t) {
-                            var typeDiv = $('<div>',{class:"red-ui-palette-module-type"}).appendTo(setRow);
-                            typeSwatches[t] = $('<span>',{class:"red-ui-palette-module-type-swatch"}).appendTo(typeDiv);
-                            $('<span>',{class:"red-ui-palette-module-type-node"}).text(t).appendTo(typeDiv);
-                        })
-                        var enableButton = $('<a href="#" class="red-ui-button red-ui-button-small"></a>').appendTo(buttonGroup);
-                        enableButton.on("click", function(evt) {
-                            evt.preventDefault();
-                            if (object.setUseCount[setName] === 0) {
-                                var currentSet = RED.nodes.registry.getNodeSet(set.id);
-                                shade.show();
-                                var newState = !currentSet.enabled
-                                changeNodeState(set.id,newState,shade,function(xhr){
-                                    if (xhr) {
-                                        if (xhr.responseJSON) {
-                                            RED.notify(RED._('palette.editor.errors.'+(newState?'enable':'disable')+'Failed',{module: id,message:xhr.responseJSON.message}));
+                    const populateSetList = function () {
+                        var setList = Object.keys(entry.sets)
+                        setList.sort(function(A,B) {
+                            return A.toLowerCase().localeCompare(B.toLowerCase());
+                        });
+                        setList.forEach(function(setName) {
+                            var set = entry.sets[setName];
+                            var setRow = $('<div>',{class:"red-ui-palette-module-set"}).appendTo(contentRow);
+                            var buttonGroup = $('<div>',{class:"red-ui-palette-module-set-button-group"}).appendTo(setRow);
+                            var typeSwatches = {};
+                            let enableButton;
+                            if (set.types) {
+                                set.types.forEach(function(t) {
+                                    var typeDiv = $('<div>',{class:"red-ui-palette-module-type"}).appendTo(setRow);
+                                    typeSwatches[t] = $('<span>',{class:"red-ui-palette-module-type-swatch"}).appendTo(typeDiv);
+                                    if (set.enabled) {
+                                        var def = RED.nodes.getType(t);
+                                        if (def && def.color) {
+                                            typeSwatches[t].css({background:RED.utils.getNodeColor(t,def)});
+                                            typeSwatches[t].css({border: "1px solid "+getContrastingBorder(typeSwatches[t].css('backgroundColor'))})
                                         }
                                     }
-                                });
+                                    $('<span>',{class:"red-ui-palette-module-type-node"}).text(t).appendTo(typeDiv);
+                                })
+                                enableButton = $('<a href="#" class="red-ui-button red-ui-button-small"></a>').appendTo(buttonGroup);
+                                enableButton.on("click", function(evt) {
+                                    evt.preventDefault();
+                                    if (object.setUseCount[setName] === 0) {
+                                        var currentSet = RED.nodes.registry.getNodeSet(set.id);
+                                        shade.show();
+                                        var newState = !currentSet.enabled
+                                        changeNodeState(set.id,newState,shade,function(xhr){
+                                            if (xhr) {
+                                                if (xhr.responseJSON) {
+                                                    RED.notify(RED._('palette.editor.errors.'+(newState?'enable':'disable')+'Failed',{module: id,message:xhr.responseJSON.message}));
+                                                }
+                                            }
+                                        });
+                                    }
+                                })
+
+                                if (object.setUseCount[setName] > 0) {
+                                    enableButton.text(RED._('palette.editor.inuse'));
+                                    enableButton.addClass('disabled');
+                                } else {
+                                    enableButton.removeClass('disabled');
+                                    if (set.enabled) {
+                                        enableButton.text(RED._('palette.editor.disable'));
+                                    } else {
+                                        enableButton.text(RED._('palette.editor.enable'));
+                                    }
+                                }
+                                setRow.toggleClass("red-ui-palette-module-set-disabled",!set.enabled);
+
+
+                            }
+                            if (set.plugins) {
+                                set.plugins.forEach(function(p) {
+                                    var typeDiv = $('<div>',{class:"red-ui-palette-module-type"}).appendTo(setRow);
+                                    // typeSwatches[p.id] = $('<span>',{class:"red-ui-palette-module-type-swatch"}).appendTo(typeDiv);
+                                    $('<span><i class="fa fa-puzzle-piece" aria-hidden="true"></i>  </span>',{class:"red-ui-palette-module-type-swatch"}).appendTo(typeDiv);
+                                    $('<span>',{class:"red-ui-palette-module-type-node"}).text(p.id).appendTo(typeDiv);
+                                })
                             }
-                        })
 
-                        object.elements.sets[set.name] = {
-                            setRow: setRow,
-                            enableButton: enableButton,
-                            swatches: typeSwatches
-                        };
-                    });
+                            object.elements.sets[set.name] = {
+                                setRow: setRow,
+                                enableButton: enableButton,
+                                swatches: typeSwatches
+                            };
+                        });
+                    }
                     enableButton.on("click", function(evt) {
                         evt.preventDefault();
                         if (object.totalUseCount === 0) {
@@ -33916,7 +34467,55 @@ RED.palette.editor = (function() {
                                                 }
                                             }
                                         ]
-                                    });                                }
+                                    });                                
+                                }
+                            } else {
+                                // dedicated list management for plugins
+                                if (entry.plugin) {
+
+                                    let e = nodeEntries[entry.name];
+                                    if (e) {
+                                        nodeList.editableList('removeItem', e);
+                                        delete nodeEntries[entry.name];
+                                    }
+
+                                    // We assume that a plugin that implements onremove
+                                    // cleans the editor accordingly of its left-overs.
+                                    let found_onremove = true;
+
+                                    let keys = Object.keys(entry.sets);
+                                    keys.forEach((key) => {
+                                        let set = entry.sets[key];
+                                        for (let i=0; i<set.plugins?.length; i++) {
+                                            let plgn = RED.plugins.getPlugin(set.plugins[i].id);
+                                            if (plgn && plgn.onremove  && typeof plgn.onremove === 'function') {
+                                                plgn.onremove();
+                                            } else {
+                                                if (plgn && plgn.onadd && typeof plgn.onadd === 'function') {
+                                                    // if there's no 'onadd', there shouldn't be any left-overs
+                                                    found_onremove = false;
+                                                }
+                                            }
+                                        }
+                                    });
+
+                                    if (!found_onremove) {
+                                        let removeNotify = RED.notify("Removed plugin " + entry.name + ". Please reload the editor to clear left-overs.",{
+                                            modal: true,
+                                            fixed: true,
+                                            type: 'warning',
+                                            buttons: [
+                                                {
+                                                    text: "Understood",
+                                                    class:"primary",
+                                                    click: function(e) {
+                                                        removeNotify.close();
+                                                    }
+                                                }
+                                            ]
+                                        });
+                                    }
+                                }        
                             }
                         })
                         notification.close();
@@ -34346,8 +34945,9 @@ RED.editor = (function() {
             nodeValue = node[property]
         }
 
-        const buttonId = `${prefix}-lookup-${property}`
-        const selectId = prefix + '-' + property
+        const addBtnId = `${prefix}-btn-${property}-add`;
+        const editBtnId = `${prefix}-btn-${property}-edit`;
+        const selectId = prefix + '-' + property;
         const input = $(`#${selectId}`);
         if (input.length === 0) {
             return;
@@ -34370,40 +34970,68 @@ RED.editor = (function() {
         select.css({
             'flex-grow': 1
         });
+
         updateConfigNodeSelect(property, type, nodeValue, prefix, filter);
-        const disableButton = function(disabled) {
-            btn.prop( "disabled", !!disabled)
-            btn.toggleClass("disabled", !!disabled)
-        }
+
         // create the edit button
-        const btn = $('<a id="' + buttonId + '" class="red-ui-button"><i class="fa fa-pencil"></i></a>')
+        const editButton = $('<a id="' + editBtnId + '" class="red-ui-button"><i class="fa fa-pencil"></i></a>')
+            .css({ "margin-left": "10px" })
+            .appendTo(outerWrap);
+
+        RED.popover.tooltip(editButton, RED._('editor.editConfig', { type }));
+
+        // create the add button
+        const addButton = $('<a id="' + addBtnId + '" class="red-ui-button"><i class="fa fa-plus"></i></a>')
             .css({ "margin-left": "10px" })
             .appendTo(outerWrap);
+        RED.popover.tooltip(addButton, RED._('editor.addNewConfig', { type }));
+
+        const disableButton = function(button, disabled) {
+            $(button).prop("disabled", !!disabled)
+            $(button).toggleClass("disabled", !!disabled)
+        };
 
         // add the click handler
-        btn.on("click", function (e) {
+        addButton.on("click", function (e) {
+            if (addButton.prop("disabled")) { return }
+            showEditConfigNodeDialog(property, type, "_ADD_", prefix, node);
+            e.preventDefault();
+        });
+        editButton.on("click", function (e) {
             const selectedOpt = select.find(":selected")
             if (selectedOpt.data('env')) { return } // don't show the dialog for env vars items (MVP. Future enhancement: lookup the env, if present, show the associated edit dialog)
-            if (btn.prop("disabled")) { return }
+            if (editButton.prop("disabled")) { return }
             showEditConfigNodeDialog(property, type, selectedOpt.val(), prefix, node);
             e.preventDefault();
         });
 
         // dont permit the user to click the button if the selected option is an env var
         select.on("change", function () {
-            const selectedOpt = select.find(":selected")
+            const selectedOpt = select.find(":selected");
+            const optionsLength = select.find("option").length;
             if (selectedOpt?.data('env')) {
-                disableButton(true)
+                disableButton(addButton, true);
+                disableButton(editButton, true);
+            // disable the edit button if no options available
+            } else if (optionsLength === 1 && selectedOpt.val() === "_ADD_") {
+                disableButton(addButton, false);
+                disableButton(editButton, true);
+            } else if (selectedOpt.val() === "") {
+                disableButton(addButton, false);
+                disableButton(editButton, true);
             } else {
-                disableButton(false)
+                disableButton(addButton, false);
+                disableButton(editButton, false);
             }
         });
+
         var label = "";
         var configNode = RED.nodes.node(nodeValue);
 
         if (configNode) {
             label = RED.utils.getNodeLabel(configNode, configNode.id);
         }
+
         input.val(label);
     }
 
@@ -34897,7 +35525,12 @@ RED.editor = (function() {
                     }
                 }
 
-                select.append('<option value="_ADD_"'+(value===""?" selected":"")+'>'+RED._("editor.addNewType", {type:label})+'</option>');
+                if (!configNodes.length) {
+                    select.append('<option value="_ADD_" selected>' + RED._("editor.addNewType", { type: label }) + '</option>');
+                } else {
+                    select.append('<option value="">' + RED._("editor.inputs.none") + '</option>');
+                }
+
                 window.setTimeout(function() { select.trigger("change");},50);
             }
         }
@@ -41007,7 +41640,7 @@ RED.editor.codeEditor.monaco = (function() {
                     createMonacoCompletionItem("set (flow context)", 'flow.set("${1:name}", ${1:value});','Set a value in flow context',range),
                     createMonacoCompletionItem("get (global context)", 'global.get("${1:name}");','Get a value from global context',range),
                     createMonacoCompletionItem("set (global context)", 'global.set("${1:name}", ${1:value});','Set a value in global context',range),
-                    createMonacoCompletionItem("get (env)", 'env.get("${1|NR_NODE_ID,NR_NODE_NAME,NR_NODE_PATH,NR_GROUP_ID,NR_GROUP_NAME,NR_FLOW_ID,NR_FLOW_NAME|}");','Get env variable value',range),
+                    createMonacoCompletionItem("get (env)", 'env.get("${1|NR_NODE_ID,NR_NODE_NAME,NR_NODE_PATH,NR_GROUP_ID,NR_GROUP_NAME,NR_FLOW_ID,NR_FLOW_NAME,NR_SUBFLOW_NAME,NR_SUBFLOW_ID,NR_SUBFLOW_PATH|}");','Get env variable value',range),
                     createMonacoCompletionItem("cloneMessage (RED.util)", 'RED.util.cloneMessage(${1:msg});',
                         ["```typescript",
                         "RED.util.cloneMessage<T extends registry.NodeMessage>(msg: T): T",
@@ -42262,6 +42895,7 @@ RED.eventLog = (function() {
                 setTimeout(function() {
                     oldTray.tray.detach();
                     showTray(options);
+                    RED.events.emit('editor:change')
                 },250)
             } else {
                 if (stack.length > 0) {
@@ -42331,6 +42965,7 @@ RED.eventLog = (function() {
                         RED.view.focus();
                     } else {
                         stack[stack.length-1].tray.css("z-index", "auto");
+                        RED.events.emit('editor:change')
                     }
                 },250)
             }
@@ -45684,10 +46319,16 @@ RED.search = (function() {
                     onselect: 'core:split-wire-with-link-nodes',
                     disabled: !canEdit || !hasLinks
                 },
-                null,
-                { onselect: 'core:show-import-dialog', label: RED._('common.label.import')},
-                { onselect: 'core:show-examples-import-dialog', label: RED._('menu.label.importExample') }
+                null
             )
+            if (RED.settings.theme("menu.menu-item-import-library", true)) {
+                insertOptions.push(
+                    { onselect: 'core:show-import-dialog', label: RED._('common.label.import')},
+                    { onselect: 'core:show-examples-import-dialog', label: RED._('menu.label.importExample') }
+                )
+            }
+
+
             if (hasSelection && canEdit) {
                 const nodeOptions = []
                 if (!hasMultipleSelection && !isGroup) {
@@ -45760,8 +46401,14 @@ RED.search = (function() {
                 { onselect: 'core:paste-from-internal-clipboard', label: RED._("keyboard.pasteNode"), disabled: !canEdit || !RED.view.clipboard() },
                 { onselect: 'core:delete-selection', label: RED._('keyboard.deleteSelected'), disabled: !canEdit || !canDelete },
                 { onselect: 'core:delete-selection-and-reconnect', label: RED._('keyboard.deleteReconnect'), disabled: !canEdit || !canDelete },
-                { onselect: 'core:show-export-dialog', label: RED._("menu.label.export") },
-                { onselect: 'core:select-all-nodes', label: RED._("keyboard.selectAll") },
+            )
+            if (RED.settings.theme("menu.menu-item-export-library", true)) {
+                menuItems.push(
+                    { onselect: 'core:show-export-dialog', label: RED._("menu.label.export") }
+                )
+            }
+            menuItems.push(
+                { onselect: 'core:select-all-nodes', label: RED._("keyboard.selectAll") }
             )
         }
 
@@ -47772,14 +48419,20 @@ RED.subflow = (function() {
                     var nodePropValue = nodeProp;
                     if (prop.ui && prop.ui.type === "cred") {
                         nodePropType = "cred";
+                    } else if (prop.ui && prop.ui.type === "conf-types") {
+                        nodePropType = prop.value.type
                     } else {
                         switch(typeof nodeProp) {
                             case "string": nodePropType = "str"; break;
                             case "number": nodePropType = "num"; break;
                             case "boolean": nodePropType = "bool"; nodePropValue = nodeProp?"true":"false"; break;
                             default:
-                            nodePropType = nodeProp.type;
-                            nodePropValue = nodeProp.value;
+                                if (nodeProp) {
+                                    nodePropType = nodeProp.type;
+                                    nodePropValue = nodeProp.value;
+                                } else {
+                                    nodePropType = 'str'
+                                }
                         }
                     }
                     var item = {