[MD Bookmarks] Flatten sidebar.

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 203 matching lines @@
         return selectedFolder;
       case 'finish-search':
         return null;
       case 'clear-search':
         return nodes['0'].children[0];
       default:
         return selectedFolder;
     }
   };
 
-  var ClosedFolderState = {};
+  var SidebarState = {};
 
   /**
-   * @param {ClosedFolderState} state
-   * @param {Action} action
-   * @param {NodeList} nodes
-   * @return {ClosedFolderState}
+   * Returns the modifications for |folders| needed to show or hide all nodes
+   * beneath |nodeId| that are not beneath a closed folder.
+   * @param {!Array<SidebarFolder>} folders
+   * @param {number} nodeIdx
+   * @param {boolean} open
+   * @return {!Array<SidebarFolder>}
    */
-  ClosedFolderState.openAncestorsOf = function(state, action, nodes) {
-    var id = action.id;
+  SidebarState.updateVisibleFoldersBelowNode = function(
+      folders, nodeIdx, open) {
+    var node = Object.assign({}, folders[nodeIdx]);
+    node.open = open;
+
+    if (!node.visible)
+      return {};
+
     var modifications = {};
-    var parentId = nodes[id].parentId;
-    while (parentId) {
-      if (state[parentId]) {
-        modifications[parentId] = false;
-      }
-      parentId = nodes[parentId].parentId;
+    var stack = [{node: node, showing: node.visible}];
+    for (var i = nodeIdx + 1; i < folders.length; i++) {
+      var n = folders[i];
+
+      // Pop off nodes deeper than the current node.
+      while (stack.length && n.depth <= stack[stack.length - 1].node.depth)
+        stack.pop();
+
+      if (!stack.length)
+        break;
+
+      var parent = stack[stack.length - 1];
+      var visible = parent.node.open && parent.showing;
+
+      // Add modification if desired visibility is not the current visibility.
+      if (visible != n.visible)
+        modifications[i] = Object.assign({}, n, {visible: visible});
+
+      // Add node to stack if it's deeper than the current node.
+      if (n.depth > parent.node.depth)
+        stack.push({node: n, showing: visible});
     }
 
-    return Object.assign({}, state, modifications);
+    return modifications;
   };
 
   /**
-   * @param {ClosedFolderState} state
+   * @param {SidebarState} state
    * @param {Action} action
-   * @return {ClosedFolderState}
+   * @return {SidebarState}
    */
-  ClosedFolderState.toggleFolderOpen = function(state, action) {
-    var id = action.id;
-    var closed = !action.open;
-    var modification = {};
-    modification[id] = closed;
+  SidebarState.changeFolderOpen = function(state, action) {
+    var newFolders = state.folders.slice();
+    var idx = state.folderMap[action.id];
+    var folder = newFolders[idx];
+    if (folder.open == action.open)
+      return state;
 
-    return Object.assign({}, state, modification);
+    newFolders[idx] = /** @type {SidebarFolder} */ (
+        Object.assign({}, folder, {open: action.open}));
+    newFolders = /** @type {!Array<SidebarFolder>} */ (Object.assign(
+        newFolders,
+        this.updateVisibleFoldersBelowNode(state.folders, idx, action.open)));
+    return /** @type {SidebarState} */ (
+        Object.assign({}, state, {folders: newFolders}));
   };
 
   /**
-   * @param {ClosedFolderState} state
+   * @param {SidebarState} state
    * @param {Action} action
    * @param {NodeList} nodes
-   * @return {ClosedFolderState}
+   * @return {SidebarState}
    */
-  ClosedFolderState.updateClosedFolders = function(state, action, nodes) {
+  SidebarState.openAncestorsOf = function(state, action, nodes) {
+    var id = action.id;
+    var newState = state;
+    var parentId = nodes[id].parentId || '';
+    while (nodes[parentId] && nodes[parentId].parentId) {
+      newState = this.changeFolderOpen(
+          newState, bookmarks.actions.changeFolderOpen(parentId, true));
+      parentId = nodes[parentId].parentId || '';
+    }
+
+    return newState;
+  };
+
+  /**
+   * @param {SidebarState} state
+   * @param {Action} action
+   * @return {SidebarState}
+   */
+  SidebarState.removeBookmark = function(state, action) {
+    var newFolders = state.folders.slice();
+
+    for (var i = 0; i < newFolders.length; i++) {
+      if (action.id != newFolders[i].id)
+        continue;
+
+      newFolders.splice(i, 1);
+    }
+
+    return /** @type {SidebarState} */ (Object.assign({}, state, {
+      folders: newFolders,
+      folderMap: bookmarks.util.createFolderMap(newFolders),
+    }));
+  };
+
+  /**
+   * @param {SidebarState} state
+   * @param {Action} action
+   * @param {NodeList} nodes
+   * @return {SidebarState}
+   */
+  SidebarState.updateSidebar = function(state, action, nodes) {
     switch (action.name) {
+      case 'remove-bookmark':
+        return this.removeBookmark(state, action);
       case 'change-folder-open':
-        return ClosedFolderState.toggleFolderOpen(state, action);
+        return this.changeFolderOpen(state, action);
       case 'select-folder':
-        return ClosedFolderState.openAncestorsOf(state, action, nodes);
+        return this.openAncestorsOf(state, action, nodes);
       default:
         return state;
     };
   };
 
   /**
    * 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
    * @return {BookmarksPageState}
    */
   function reduceAction(state, action) {
     return {
       nodes: NodeState.updateNodes(state.nodes, action),
+      search: SearchState.updateSearch(state.search, action),
       selectedFolder: SelectedFolderState.updateSelectedFolder(
           state.selectedFolder, action, state.nodes),
-      closedFolders: ClosedFolderState.updateClosedFolders(
-          state.closedFolders, action, state.nodes),
-      search: SearchState.updateSearch(state.search, action),
       selection: SelectionState.updateSelection(state.selection, action),
+      sidebar: SidebarState.updateSidebar(state.sidebar, action, state.nodes),
     };
   }
 
   return {
     reduceAction: reduceAction,
-    ClosedFolderState: ClosedFolderState,
     NodeState: NodeState,
     SearchState: SearchState,
     SelectedFolderState: SelectedFolderState,
     SelectionState: SelectionState,
+    SidebarState: SidebarState,
   };
 });