wunderbaum 0.0.6 → 0.0.8

package/src/wunderbaum.ts

@@ -23,8 +23,9 @@ import {
   ApplyCommandType,
   ChangeType,
   ColumnDefinitionList,
+  ExpandAllOptions,
   FilterModeType,
-  MatcherType,
+  MatcherCallback,
   NavigationOptions,
   NodeStatusType,
   NodeTypeDefinitions,
@@ -710,13 +711,13 @@ export class Wunderbaum {
   /**
    * Apply a modification (or navigation) operation on the **tree or active node**.
    */
-  applyCommand(cmd: ApplyCommandType, opts?: any): any;
+  applyCommand(cmd: ApplyCommandType, options?: any): any;
 
   /**
    * Apply a modification (or navigation) operation on a **node**.
    * @see {@link WunderbaumNode.applyCommand}
    */
-  applyCommand(cmd: ApplyCommandType, node: WunderbaumNode, opts?: any): any;
+  applyCommand(cmd: ApplyCommandType, node: WunderbaumNode, options?: any): any;
 
   /**
    * Apply a modification or navigation operation.
@@ -737,23 +738,23 @@ export class Wunderbaum {
   applyCommand(
     cmd: ApplyCommandType,
     nodeOrOpts?: WunderbaumNode | any,
-    opts?: any
+    options?: any
   ): any {
     let // clipboard,
       node,
       refNode;
-    // opts = $.extend(
+    // options = $.extend(
     // 	{ setActive: true, clipboard: CLIPBOARD },
-    // 	opts_
+    // 	options_
     // );
     if (nodeOrOpts instanceof WunderbaumNode) {
       node = nodeOrOpts;
     } else {
       node = this.getActiveNode()!;
-      util.assert(opts === undefined);
-      opts = nodeOrOpts;
+      util.assert(options === undefined);
+      options = nodeOrOpts;
     }
-    // clipboard = opts.clipboard;
+    // clipboard = options.clipboard;
 
     switch (cmd) {
       // Sorting and indentation:
@@ -973,15 +974,8 @@ export class Wunderbaum {
   }
 
   /** Recursively expand all expandable nodes (triggers lazy load id needed). */
-  async expandAll(flag: boolean = true) {
-    const tag = this.logTime("expandAll(" + flag + ")");
-    try {
-      this.enableUpdate(false);
-      await this.root.expandAll(flag);
-    } finally {
-      this.enableUpdate(true);
-      this.logTimeEnd(tag);
-    }
+  async expandAll(flag: boolean = true, options?: ExpandAllOptions) {
+    await this.root.expandAll(flag, options);
   }
 
   /** Recursively select all nodes. */
@@ -1018,26 +1012,20 @@ export class Wunderbaum {
   }
 
   /**
-   * Find all nodes that matches condition.
-   *
-   * @param match title string to search for, or a
-   *     callback function that returns `true` if a node is matched.
+   * Find all nodes that match condition.
    *
    * @see {@link WunderbaumNode.findAll}
    */
-  findAll(match: string | MatcherType) {
+  findAll(match: string | RegExp | MatcherCallback) {
     return this.root.findAll(match);
   }
 
   /**
    * Find first node that matches condition.
    *
-   * @param match title string to search for, or a
-   *     callback function that returns `true` if a node is matched.
    * @see {@link WunderbaumNode.findFirst}
-   *
    */
-  findFirst(match: string | MatcherType) {
+  findFirst(match: string | RegExp | MatcherCallback) {
     return this.root.findFirst(match);
   }
 
@@ -1049,8 +1037,8 @@ export class Wunderbaum {
    * @see {@link WunderbaumNode.findFirst}
    *
    */
-  findKey(key: string): WunderbaumNode | undefined {
-    return this.keyMap.get(key);
+  findKey(key: string): WunderbaumNode | null {
+    return this.keyMap.get(key) || null;
   }
 
   /**
@@ -1058,7 +1046,7 @@ export class Wunderbaum {
    * and wrap-around at the end.
    */
   findNextNode(
-    match: string | MatcherType,
+    match: string | MatcherCallback,
     startNode?: WunderbaumNode | null
   ): WunderbaumNode | null {
     //, visibleOnly) {
@@ -1374,19 +1362,22 @@ export class Wunderbaum {
 
   /**
    * Make sure that this node is vertically scrolled into the viewport.
+   *
+   * Nodes that are above the visible area become the top row, nodes that are
+   * below the viewport become the bottom row.
    */
   scrollTo(nodeOrOpts: ScrollToOptions | WunderbaumNode) {
     const PADDING = 2; // leave some pixels between viewport bounds
 
     let node;
     WunderbaumNode;
-    let opts: ScrollToOptions | undefined;
+    let options: ScrollToOptions | undefined;
 
     if (nodeOrOpts instanceof WunderbaumNode) {
       node = nodeOrOpts;
     } else {
-      opts = nodeOrOpts;
-      node = opts.node;
+      options = nodeOrOpts;
+      node = options.node;
     }
     util.assert(node && node._rowIdx != null);
 
@@ -1398,6 +1389,7 @@ export class Wunderbaum {
     const vpTop = headerHeight;
     const vpRowTop = rowTop - scrollTop;
     const vpRowBottom = vpRowTop + ROW_HEIGHT;
+    const topNode = options?.topNode;
 
     // this.log( `scrollTo(${node.title}), vpTop:${vpTop}px, scrollTop:${scrollTop}, vpHeight:${vpHeight}, rowTop:${rowTop}, vpRowTop:${vpRowTop}`, nodeOrOpts );
     let newScrollTop: number | null = null;
@@ -1408,16 +1400,20 @@ export class Wunderbaum {
       } else {
         // Node is below viewport
         // this.log("Below viewport");
-        newScrollTop = rowTop + ROW_HEIGHT - vpHeight + PADDING; // leave some pixels between vieeport bounds
+        newScrollTop = rowTop + ROW_HEIGHT - vpHeight + PADDING; // leave some pixels between viewport bounds
       }
     } else {
       // Node is above viewport
       // this.log("Above viewport");
-      newScrollTop = rowTop - vpTop - PADDING; // leave some pixels between vieeport bounds
+      newScrollTop = rowTop - vpTop - PADDING; // leave some pixels between viewport bounds
     }
     if (newScrollTop != null) {
       this.log(`scrollTo(${rowTop}): ${scrollTop} => ${newScrollTop}`);
       scrollParent.scrollTop = newScrollTop;
+      if (topNode) {
+        // Make sure the topNode is always visible
+        this.scrollTo(topNode);
+      }
       // this.setModified(ChangeType.vscroll);
     }
   }
@@ -1447,13 +1443,9 @@ export class Wunderbaum {
       newLeft = colRight - vpWidth;
     }
     // util.assert(node._rowIdx != null);
-    // const curLeft = this.scrollContainer.scrollLeft;
-    this.log(
-      `scrollToHorz(${this.activeColIdx}): ${colLeft}..${colRight}, fixedOfs=${fixedWidth}, vpWidth=${vpWidth}, curLeft=${scrollLeft} -> ${newLeft}`
-    );
-    // const nodeOfs = node._rowIdx * ROW_HEIGHT;
-    // let newLeft;
-
+    // this.log(
+    //   `scrollToHorz(${this.activeColIdx}): ${colLeft}..${colRight}, fixedOfs=${fixedWidth}, vpWidth=${vpWidth}, curLeft=${scrollLeft} -> ${newLeft}`
+    // );
     this.element.scrollLeft = newLeft;
     // this.setModified(ChangeType.vscroll);
     // }
@@ -1666,11 +1658,13 @@ export class Wunderbaum {
     }
   }
   /** Update column headers and width. */
-  updateColumns(opts?: any) {
-    opts = Object.assign({ calculateCols: true, updateRows: true }, opts);
+  updateColumns(options?: any) {
+    options = Object.assign({ calculateCols: true, updateRows: true }, options);
     const defaultMinWidth = 4;
     const vpWidth = this.element.clientWidth;
     const isGrid = this.isGrid();
+    // Shorten last column width to avoid h-scrollbar
+    const FIX_ADJUST_LAST_COL = 2;
 
     let totalWidth = 0;
     let totalWeight = 0;
@@ -1682,7 +1676,7 @@ export class Wunderbaum {
       this.setCellNav(false);
     }
 
-    if (opts.calculateCols) {
+    if (options.calculateCols) {
       // Gather width definitions
       this._columnsById = {};
       for (let col of this.columns) {
@@ -1732,7 +1726,8 @@ export class Wunderbaum {
         col._ofsPx = ofsPx;
         ofsPx += col._widthPx!;
       }
-      totalWidth = ofsPx;
+      this.columns[this.columns.length - 1]._widthPx! -= FIX_ADJUST_LAST_COL;
+      totalWidth = ofsPx - FIX_ADJUST_LAST_COL;
     }
     // if (this.options.fixedCol) {
     // 'position: fixed' requires that the content has the correct size
@@ -1747,7 +1742,7 @@ export class Wunderbaum {
     // util.error("BREAK");
     if (modified) {
       this._renderHeaderMarkup();
-      if (opts.updateRows) {
+      if (options.updateRows) {
         this._updateRows();
       }
     }
@@ -1815,6 +1810,9 @@ export class Wunderbaum {
    * @internal
    */
   protected _updateViewportImmediately() {
+    // Shorten container height to avoid v-scrollbar
+    const FIX_ADJUST_HEIGHT = 1;
+
     if (this._disableUpdateCount) {
       this.log(
         `IGNORED _updateViewportImmediately() disable level: ${this._disableUpdateCount}`
@@ -1831,7 +1829,8 @@ export class Wunderbaum {
     // let headerHeight = this.headerElement.children[0].children[0].clientHeight;
     // const headerHeight = this.options.headerHeightPx;
     const headerHeight = this.headerElement.clientHeight; // May be 0
-    const wantHeight = this.element.clientHeight - headerHeight;
+    const wantHeight =
+      this.element.clientHeight - headerHeight - FIX_ADJUST_HEIGHT;
 
     if (Math.abs(height - wantHeight) > 1.0) {
       // this.log("resize", height, wantHeight);
@@ -1895,15 +1894,16 @@ export class Wunderbaum {
    *   (including upper and lower prefetch)
    * -
    */
-  protected _updateRows(opts?: any): boolean {
+  protected _updateRows(options?: any): boolean {
     // const label = this.logTime("_updateRows");
     // this.log("_updateRows", opts)
-    opts = Object.assign({ newNodesOnly: false }, opts);
-    const newNodesOnly = !!opts.newNodesOnly;
+    options = Object.assign({ newNodesOnly: false }, options);
+    const newNodesOnly = !!options.newNodesOnly;
 
     const row_height = ROW_HEIGHT;
     const vp_height = this.element.clientHeight;
     const prefetch = RENDER_MAX_PREFETCH;
+    // const grace_prefetch = RENDER_MAX_PREFETCH - RENDER_MIN_PREFETCH;
     const ofs = this.element.scrollTop;
 
     let startIdx = Math.max(0, ofs / row_height - prefetch);
@@ -2008,15 +2008,15 @@ export class Wunderbaum {
    *     {start: First tree node, reverse: false, includeSelf: true, includeHidden: false, wrap: false}
    * @returns {boolean} false if iteration was canceled
    */
-  visitRows(callback: (node: WunderbaumNode) => any, opts?: any): boolean {
+  visitRows(callback: (node: WunderbaumNode) => any, options?: any): boolean {
     if (!this.root.hasChildren()) {
       return false;
     }
-    if (opts && opts.reverse) {
-      delete opts.reverse;
-      return this._visitRowsUp(callback, opts);
+    if (options && options.reverse) {
+      delete options.reverse;
+      return this._visitRowsUp(callback, options);
     }
-    opts = opts || {};
+    options = options || {};
     let i,
       nextIdx,
       parent,
@@ -2024,10 +2024,10 @@ export class Wunderbaum {
       siblings,
       stopNode: WunderbaumNode,
       siblingOfs = 0,
-      skipFirstNode = opts.includeSelf === false,
-      includeHidden = !!opts.includeHidden,
+      skipFirstNode = options.includeSelf === false,
+      includeHidden = !!options.includeHidden,
       checkFilter = !includeHidden && this.filterMode === "hide",
-      node: WunderbaumNode = opts.start || this.root.children![0];
+      node: WunderbaumNode = options.start || this.root.children![0];
 
     parent = node.parent;
     while (parent) {
@@ -2086,11 +2086,11 @@ export class Wunderbaum {
       parent = parent.parent;
       siblingOfs = 1; //
 
-      if (!parent && opts.wrap) {
+      if (!parent && options.wrap) {
         this.logDebug("visitRows(): wrap around");
-        util.assert(opts.start, "`wrap` option requires `start`");
-        stopNode = opts.start;
-        opts.wrap = false;
+        util.assert(options.start, "`wrap` option requires `start`");
+        stopNode = options.start;
+        options.wrap = false;
         parent = this.root;
         siblingOfs = 0;
       }