Merge branch 'dev' into group-rework

packages/node_modules/@node-red/editor-client/src/js/nodes.js

@@ -46,6 +46,9 @@ RED.nodes = (function() {
 
     function setDirty(d) {
         dirty = d;
+        if (!d) {
+            allNodes.clearState()
+        }
         RED.events.emit("workspace:dirty",{dirty:dirty});
     }
 
@@ -237,8 +240,16 @@ RED.nodes = (function() {
 
     // allNodes holds information about the Flow nodes.
     var allNodes = (function() {
+        // Map node.id -> node
         var nodes = {};
+        // Map tab.id -> Array of nodes on that tab
         var tabMap = {};
+        // Map tab.id -> Set of dirty object ids on that tab
+        var tabDirtyMap = {};
+        // Map tab.id -> Set of object ids of things deleted from the tab that weren't otherwise dirty
+        var tabDeletedNodesMap = {};
+        // Set of object ids of things added to a tab after initial import
+        var addedDirtyObjects = new Set()
 
         function changeCollectionDepth(tabNodes, toMove, direction, singleStep) {
             const result = []
@@ -279,17 +290,22 @@ RED.nodes = (function() {
         var api = {
             addTab: function(id) {
                 tabMap[id] = [];
+                tabDirtyMap[id] = new Set();
+                tabDeletedNodesMap[id] = new Set();
             },
             hasTab: function(z) {
                 return tabMap.hasOwnProperty(z)
             },
             removeTab: function(id) {
                 delete tabMap[id];
+                delete tabDirtyMap[id];
+                delete tabDeletedNodesMap[id];
             },
             addNode: function(n) {
                 nodes[n.id] = n;
                 if (tabMap.hasOwnProperty(n.z)) {
                     tabMap[n.z].push(n);
+                    api.addObjectToWorkspace(n.z, n.id, n.changed || n.moved)
                 } else {
                     console.warn("Node added to unknown tab/subflow:",n);
                     tabMap["_"] = tabMap["_"] || [];
@@ -303,8 +319,37 @@ RED.nodes = (function() {
                     if (i > -1) {
                         tabMap[n.z].splice(i,1);
                     }
+                    api.removeObjectFromWorkspace(n.z, n.id)
                 }
             },
+            /**
+             * Add an object to our dirty/clean tracking state
+             * @param {String} z 
+             * @param {String} id 
+             * @param {Boolean} isDirty 
+             */
+            addObjectToWorkspace: function (z, id, isDirty) {
+                if (isDirty) {
+                    addedDirtyObjects.add(id)
+                }
+                if (tabDeletedNodesMap[z].has(id)) {
+                    tabDeletedNodesMap[z].delete(id)
+                }
+                api.markNodeDirty(z, id, isDirty)
+            },
+            /**
+             * Remove an object from our dirty/clean tracking state
+             * @param {String} z 
+             * @param {String} id 
+             */
+            removeObjectFromWorkspace: function (z, id) {
+                if (!addedDirtyObjects.has(id)) {
+                    tabDeletedNodesMap[z].add(id)
+                } else {
+                    addedDirtyObjects.delete(id)
+                }
+                api.markNodeDirty(z, id, false)
+            },
             hasNode: function(id) {
                 return nodes.hasOwnProperty(id);
             },
@@ -371,6 +416,33 @@ RED.nodes = (function() {
             clear: function() {
                 nodes = {};
                 tabMap = {};
+                tabDirtyMap = {};
+                tabDeletedNodesMap = {};
+                addedDirtyObjects = new Set();
+            },
+            /**
+             * Clear all internal state on what is dirty.
+             */
+            clearState: function () {
+                // Called when a deploy happens, we can forget about added/remove
+                // items as they have now been deployed.
+                addedDirtyObjects = new Set()
+                const flowsToCheck = new Set()
+                for (const [z, set] of Object.entries(tabDeletedNodesMap)) {
+                    if (set.size > 0) {
+                        set.clear()
+                        flowsToCheck.add(z)
+                    }
+                }
+                for (const [z, set] of Object.entries(tabDirtyMap)) {
+                    if (set.size > 0) {
+                        set.clear()
+                        flowsToCheck.add(z)
+                    }
+                }
+                for (const z of flowsToCheck) {
+                    api.checkTabState(z)
+                }
             },
             eachNode: function(cb) {
                 var nodeList,i,j;
@@ -453,6 +525,36 @@ RED.nodes = (function() {
                         return orderMap[A.id] - orderMap[B.id];
                     })
                 }
+            },
+            /**
+             * Update our records if an object is dirty or not
+             * @param {String} z tab id
+             * @param {String} id object id
+             * @param {Boolean} dirty whether the object is dirty or not
+             */
+            markNodeDirty: function(z, id, dirty) {
+                if (tabDirtyMap[z]) {
+                    if (dirty) {
+                        tabDirtyMap[z].add(id)
+                    } else {
+                        tabDirtyMap[z].delete(id)
+                    }
+                    api.checkTabState(z)
+                }
+            },
+            /**
+             * Check if a tab should update its contentsChange flag
+             * @param {String} z tab id
+             */
+            checkTabState: function (z) {
+                const ws = workspaces[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);
+                    }
+                }
             }
         }
         return api;
@@ -540,6 +642,11 @@ RED.nodes = (function() {
                     throw new Error(`Cannot modified property '${prop}' of locked object '${node.type}:${node.id}'`)
                 }
             }
+            if (node.z && (prop === 'changed' || prop === 'moved')) {
+                setTimeout(() => {
+                    allNodes.markNodeDirty(node.z, node.id, node.changed || node.moved)
+                }, 0)
+            }
             node[prop] = value;
             return true
         }
@@ -609,10 +716,16 @@ RED.nodes = (function() {
         }
         if (l.source.z === l.target.z && linkTabMap[l.source.z]) {
             linkTabMap[l.source.z].push(l);
+            allNodes.addObjectToWorkspace(l.source.z, getLinkId(l), true)
         }
         RED.events.emit("links:add",l);
     }
 
+    function getLinkId(link) {
+        return link.source.id + ':' + link.sourcePort + ':' + link.target.id
+    }
+
+
     function getNode(id) {
         if (id in configNodes) {
             return configNodes[id];
@@ -807,6 +920,7 @@ RED.nodes = (function() {
                 if (index !== -1) {
                     linkTabMap[l.source.z].splice(index,1)
                 }
+                allNodes.removeObjectFromWorkspace(l.source.z, getLinkId(l))
             }
         }
         RED.events.emit("links:remove",l);
@@ -1631,6 +1745,7 @@ RED.nodes = (function() {
      * Options:
      *  - generateIds - whether to replace all node ids
      *  - addFlow - whether to import nodes to a new tab
+     *  - markChanged - whether to set changed=true on all newly imported objects
      *  - reimport - if node has a .z property, dont overwrite it
      *               Only applicible when `generateIds` is false
      *  - importMap - how to resolve any conflicts.
@@ -1639,7 +1754,7 @@ RED.nodes = (function() {
      *       - id:replace - import over the top of existing
      */
     function importNodes(newNodesObj,options) { // createNewIds,createMissingWorkspace) {
-        const defOpts = { generateIds: false, addFlow: false, reimport: false, importMap: {} }
+        const defOpts = { generateIds: false, addFlow: false, markChanged: false, reimport: false, importMap: {} }
         options = Object.assign({}, defOpts, options)
         options.importMap = options.importMap || {}
         const createNewIds = options.generateIds;
@@ -1665,7 +1780,7 @@ RED.nodes = (function() {
             newNodes = newNodesObj;
         }
 
-        if (!$.isArray(newNodes)) {
+        if (!Array.isArray(newNodes)) {
             newNodes = [newNodes];
         }
 
@@ -1963,6 +2078,9 @@ RED.nodes = (function() {
                     if (!n.z) {
                         delete configNode.z;
                     }
+                    if (options.markChanged) {
+                        configNode.changed = true
+                    }
                     if (n.hasOwnProperty('d')) {
                         configNode.d = n.d;
                     }
@@ -2025,6 +2143,9 @@ RED.nodes = (function() {
                     if (n.hasOwnProperty('g')) {
                         node.g = n.g;
                     }
+                    if (options.markChanged) {
+                        node.changed = true
+                    }
                     if (createNewIds || options.importMap[n.id] === "copy") {
                         if (subflow_denylist[n.z]) {
                             continue;
@@ -2245,7 +2366,7 @@ RED.nodes = (function() {
             // get added
             if (activeSubflow && /^link /.test(n.type) && n.links) {
                 n.links = n.links.filter(function(id) {
-                    var otherNode = RED.nodes.node(id);
+                    const otherNode = node_map[id] || RED.nodes.node(id);
                     return (otherNode && otherNode.z === activeWorkspace)
                 });
             }
@@ -2538,6 +2659,7 @@ RED.nodes = (function() {
         groupsByZ[group.z] = groupsByZ[group.z] || [];
         groupsByZ[group.z].push(group);
         groups[group.id] = group;
+        allNodes.addObjectToWorkspace(group.z, group.id, group.changed || group.moved)
         RED.events.emit("groups:add",group);
         return group
     }
@@ -2554,7 +2676,7 @@ RED.nodes = (function() {
             }
         }
         RED.group.markDirty(group);
-
+        allNodes.removeObjectFromWorkspace(group.z, group.id)
         delete groups[group.id];
         RED.events.emit("groups:remove",group);
     }
@@ -2573,6 +2695,7 @@ RED.nodes = (function() {
         if (!nodeLinks[junction.id]) {
             nodeLinks[junction.id] = {in:[],out:[]};
         }
+        allNodes.addObjectToWorkspace(junction.z, junction.id, junction.changed || junction.moved)
         RED.events.emit("junctions:add", junction)
         return junction
     }
@@ -2584,6 +2707,7 @@ RED.nodes = (function() {
         }
         delete junctions[junction.id]
         delete nodeLinks[junction.id];
+        allNodes.removeObjectFromWorkspace(junction.z, junction.id)
         RED.events.emit("junctions:remove", junction)
 
         var removedLinks = links.filter(function(l) { return (l.source === junction) || (l.target === junction); });
@@ -2821,6 +2945,9 @@ RED.nodes = (function() {
                     RED.view.redraw(true);
                 }
             });
+            RED.events.on('deploy', function () {
+                allNodes.clearState()
+            })
         },
         registry:registry,
         setNodeList: registry.setNodeList,
@@ -2923,6 +3050,20 @@ RED.nodes = (function() {
                 }
             }
         },
+        eachGroup: function(cb) {
+            for (var group of Object.values(groups)) {
+                if (cb(group) === false) {
+                    break
+                }
+            }
+        },
+        eachJunction: function(cb) {
+            for (var junction of Object.values(junctions)) {
+                if (cb(junction) === false) {
+                    break
+                }
+            }
+        },
 
         node: getNode,