MD Bookmarks: Remove deleted nodes from state tree

chrome/browser/resources/md_bookmarks/reducers.js

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Module of functions which produce a new page state in response
  * to an action. Reducers (in the same sense as Array.prototype.reduce) must be
  * pure functions: they must not modify existing state objects, or make any API
  * calls.
  */
@@ skipping 26 matching lines @@
    * @return {SelectionState}
    */
   SelectionState.deselectAll = function(selectionState) {
     return {
       items: {},
       anchor: null,
     };
   };
 
   /**
+   * @param {SelectionState} selectionState
+   * @param {!Set<string>} deleted
+   * @return SelectionState
+   */
+  SelectionState.deselectDeletedItems = function(selectionState, deleted) {
+    return /** @type {SelectionState} */ Object.assign({}, selectionState, {
+      items: bookmarks.util.removeNodesFromMap(selectionState.items, deleted),

[calamity, 2017/04/03 06:54:24]

When this turns into a Set, this won't work anymore and we'll need a separate
removeKeysFromSet() function.

[tsergeant, 2017/04/04 04:42:27]

I've rebased onto your Map->Set CL, and added a new removeIdsFromSet() function.

+      anchor: null,

[calamity, 2017/04/03 06:54:24]

nit: Ideally the anchor remains on the same item it was, but I'm not super
fussed about that I guess.

[tsergeant, 2017/04/04 04:42:27]

My general feeling is that it's not really worth the effort to keep the anchor
correct after the user does something complex like a deletion.

+    });
+  };
+
+  /**
    * @param {SelectionState} selection
    * @param {Action} action
    * @return {SelectionState}
    */
   SelectionState.updateSelection = function(selection, action) {
     switch (action.name) {
       case 'clear-search':
       case 'finish-search':
       case 'select-folder':
         return SelectionState.deselectAll(selection);
       case 'select-items':
         return SelectionState.selectItems(selection, action);
+      case 'remove-bookmark':
+        return SelectionState.deselectDeletedItems(
+            selection, action.descendants);
+      default:
+        return selection;
     }
-    return selection;
   };
 
   var SearchState = {};
 
   /**
    * @param {SearchState} search
    * @param {Action} action
    * @return {SearchState}
    */
   SearchState.startSearch = function(search, action) {
@@ skipping 20 matching lines @@
   SearchState.clearSearch = function() {
     return {
       term: '',
       inProgress: false,
       results: [],
     };
   };
 
   /**
    * @param {SearchState} search
+   * @param {!Set<string>} deletedIds
+   * @return {SearchState}
+   */
+  SearchState.removeDeletedResults = function(search, deletedIds) {
+    var newResults = [];
+    search.results.forEach(function(id) {
+      if (!deletedIds.has(id))
+        newResults.push(id);
+    });
+    return /** @type {SearchState} */ (Object.assign({}, search, {
+      results: newResults,
+    }));
+  };
+
+  /**
+   * @param {SearchState} search
    * @param {Action} action
    * @return {SearchState}
    */
   SearchState.updateSearch = function(search, action) {
     switch (action.name) {
       case 'start-search':
         return SearchState.startSearch(search, action);
       case 'select-folder':
       case 'clear-search':
         return SearchState.clearSearch();
       case 'finish-search':
         return SearchState.finishSearch(search, action);
+      case 'remove-bookmark':
+        return SearchState.removeDeletedResults(search, action.descendants);
       default:
         return search;
     }
   };
 
   var NodeState = {};
 
   /**
    * @param {NodeList} nodes
    * @param {string} id
@@ skipping 21 matching lines @@
           Object.assign({}, node, action.changeInfo));
     });
   };
 
   /**
    * @param {NodeList} nodes
    * @param {Action} action
    * @return {NodeList}
    */
   NodeState.removeBookmark = function(nodes, action) {
-    return NodeState.modifyNode_(nodes, action.parentId, function(node) {
-      var newChildren = node.children.slice();
-      newChildren.splice(action.index, 1);
-      return /** @type {BookmarkNode} */ (
-          Object.assign({}, node, {children: newChildren}));
-    });
+    var newState =
+        NodeState.modifyNode_(nodes, action.parentId, function(node) {
+          var newChildren = node.children.slice();
+          newChildren.splice(action.index, 1);
+          return /** @type {BookmarkNode} */ (
+              Object.assign({}, node, {children: newChildren}));
+        });
+
+    return bookmarks.util.removeNodesFromMap(newState, action.descendants);
   };
 
   /**
    * @param {NodeList} nodes
    * @param {Action} action
    * @return {NodeList}
    */
   NodeState.moveBookmark = function(nodes, action) {
     var nodeModifications = {};
     var id = action.id;
@@ skipping 61 matching lines @@
   };
 
   /**
    * @param {?string} selectedFolder
    * @param {Action} action
    * @param {NodeList} nodes
    * @return {?string}
    */
   SelectedFolderState.updateSelectedFolder = function(
       selectedFolder, action, nodes) {
-    // TODO(tsergeant): It should not be possible to select a non-folder.
-    // TODO(tsergeant): Select parent folder when selected folder is deleted.
     switch (action.name) {
       case 'select-folder':
+        // TODO(tsergeant): It should not be possible to select a non-folder.
         return action.id;
       case 'change-folder-open':
         // When hiding the selected folder by closing its ancestor, select
         // that ancestor instead.
         if (!action.open && selectedFolder &&
             SelectedFolderState.isAncestorOf(
                 nodes, action.id, selectedFolder)) {
           return action.id;
         }
         return selectedFolder;
       case 'finish-search':
         return null;
       case 'clear-search':
         // TODO(tsergeant): Return to the folder that was selected before the
         // search.
         return nodes['0'].children[0];
+      case 'remove-bookmark':
+        // When deleting the selected folder (or its ancestor), select the
+        // parent of the deleted node.
+        if (selectedFolder &&
+            SelectedFolderState.isAncestorOf(nodes, action.id, selectedFolder))
+          return assert(nodes[action.id].parentId);
+        return selectedFolder;
       default:
         return selectedFolder;
     }
   };
 
   var ClosedFolderState = {};
 
   /**
    * @param {ClosedFolderState} closedFolders
    * @param {string|undefined} id
@@ skipping 40 matching lines @@
         return ClosedFolderState.changeFolderOpen(closedFolders, action);
       case 'select-folder':
         return ClosedFolderState.openFolderAndAncestors(
             closedFolders, nodes[action.id].parentId, nodes);
       case 'move-bookmark':
         if (!nodes[action.id].children)
           return closedFolders;
 
         return ClosedFolderState.openFolderAndAncestors(
             closedFolders, action.parentId, nodes);
+      case 'remove-bookmark':
+        return bookmarks.util.removeNodesFromMap(
+            closedFolders, action.descendants);
       default:
         return closedFolders;
     };
   };
 
   /**
    * Root reducer for the Bookmarks page. This is called by the store in
    * response to an action, and the return value is used to update the UI.
    * @param {!BookmarksPageState} state
    * @param {Action} action
@@ skipping 13 matching lines @@
 
   return {
     reduceAction: reduceAction,
     ClosedFolderState: ClosedFolderState,
     NodeState: NodeState,
     SearchState: SearchState,
     SelectedFolderState: SelectedFolderState,
     SelectionState: SelectionState,
   };
 });