wunderbaum 0.11.1 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wunderbaum",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "title": "A treegrid control.",
   "description": "JavaScript tree/grid/treegrid control.",
   "homepage": "https://github.com/mar10/wunderbaum",
@@ -47,40 +47,42 @@
     "control"
   ],
   "devDependencies": {
-    "@rollup/plugin-replace": "^5.0.2",
-    "@rollup/plugin-terser": "^0.4.3",
-    "@rollup/plugin-typescript": "^11.1.1",
-    "@types/jest": "^29.5.2",
-    "@typescript-eslint/eslint-plugin": "^6.7.5",
-    "@typescript-eslint/parser": "^6.7.5",
-    "concurrently": "^8.1.0",
-    "eslint": "^8.51.0",
-    "eslint-config-jquery": "^3.0.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-prettier": "^4.2.1",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.20.0",
+    "@rollup/plugin-replace": "^6.0.2",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/jest": "^29.5.14",
+    "@typescript-eslint/eslint-plugin": "^8.24.0",
+    "@typescript-eslint/parser": "^8.24.0",
+    "concurrently": "^9.1.2",
+    "eslint": "^9.20.1",
+    "eslint-config-jquery": "^3.0.2",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.2.3",
     "grunt": "^1.6.1",
-    "grunt-contrib-connect": "^3.0.0",
+    "grunt-contrib-connect": "^5.0.1",
     "grunt-contrib-qunit": "^10.1.1",
     "grunt-contrib-watch": "^1.1.0",
     "grunt-exec": "^3.0.0",
     "grunt-yabs": "^1.3.0",
     "http-server": "^14.1.1",
-    "nodemon": "^2.0.22",
-    "postcss": "^8.2.24",
+    "nodemon": "^3.1.9",
+    "postcss": "^8.5.2",
     "postcss-url": "^10.1.3",
-    "prettier": "^2.8.8",
-    "pretty-quick": "^3.1.3",
-    "puppeteer": "^23.10.0",
-    "qunit": "^2.19.4",
-    "rollup": "^3.23.0",
-    "rollup-plugin-scss": "^4.0.0",
-    "sass": "^1.63.6",
-    "terser": "^5.17.7",
-    "ts-jest": "^29.1.0",
-    "ts-node": "^10.9.1",
-    "tslib": "^2.5.2",
-    "typedoc": "^0.25.2",
-    "typescript": "^5.2.2",
+    "prettier": "^3.5.1",
+    "pretty-quick": "^4.0.0",
+    "puppeteer": "^24.2.0",
+    "qunit": "^2.24.1",
+    "rollup": "^4.34.6",
+    "rollup-plugin-scss": "^4.0.1",
+    "sass": "^1.84.0",
+    "terser": "^5.39.0",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.27.7",
+    "typescript": "^5.7",
     "yarn-audit-fix": "^10.1.1"
   },
   "nodemonConfig": {

package/src/common.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - common
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 
@@ -36,8 +36,11 @@ export const TEST_IMG = new RegExp(/\.|\//);
 // export const INVALID_REQUEST_TARGET_ERROR = "$request_target_invalid";
 
 /**
- * Default node icons.
- * Requires bootstrap icons https://icons.getbootstrap.com
+ * Default node icons for icon libraries
+ *
+ *  - 'bootstrap': {@link https://icons.getbootstrap.com}
+ *  - 'fontawesome6' {@link https://fontawesome.com/icons}
+ *
  */
 export const iconMaps: { [key: string]: { [key: string]: string } } = {
   bootstrap: {
@@ -205,10 +208,12 @@ export function nodeTitleSorter(a: WunderbaumNode, b: WunderbaumNode): number {
 /**
  * Convert 'flat' to 'nested' format.
  *
- *  Flat node entry format:
- *    [PARENT_ID, [POSITIONAL_ARGS]]
- *  or
- *    [PARENT_ID, [POSITIONAL_ARGS], {KEY_VALUE_ARGS}]
+ * Flat node entry format:
+ *    [PARENT_IDX, {KEY_VALUE_ARGS}]
+ * or, if N _positional re defined:
+ *    [PARENT_IDX, POSITIONAL_ARG_1, POSITIONAL_ARG_2, ..., POSITIONAL_ARG_N]
+ * Even if _positional additional are defined, KEY_VALUE_ARGS can be appended:
+ *    [PARENT_IDX, POSITIONAL_ARG_1, ..., {KEY_VALUE_ARGS}]
  *
  * 1. Parent-referencing list is converted to a list of nested dicts with
  *    optional `children` properties.
@@ -216,11 +221,12 @@ export function nodeTitleSorter(a: WunderbaumNode, b: WunderbaumNode): number {
  */
 function unflattenSource(source: SourceObjectType): void {
   const { _format, _keyMap = {}, _positional = [], children } = source;
+  const _positionalCount = _positional.length;
 
   if (_format !== "flat") {
     throw new Error(`Expected source._format: "flat", but got ${_format}`);
   }
-  if (_positional && _positional.includes("children")) {
+  if (_positionalCount && _positional.includes("children")) {
     throw new Error(
       `source._positional must not include "children": ${_positional}`
     );
@@ -236,7 +242,7 @@ function unflattenSource(source: SourceObjectType): void {
       longToShort[value] = key;
     }
   }
-  const positionalShort = _positional.map((e: string) => longToShort[e]);
+  const positionalShort = _positional.map((e: string) => longToShort[e] ?? e);
   const newChildren: SourceListType = [];
   const keyToNodeMap: { [key: string]: number } = {};
   const indexToNodeMap: { [key: number]: any } = {};
@@ -247,21 +253,33 @@ function unflattenSource(source: SourceObjectType): void {
     // Node entry format:
     //   [PARENT_ID, [POSITIONAL_ARGS]]
     // or
-    //   [PARENT_ID, [POSITIONAL_ARGS], {KEY_VALUE_ARGS}]
-    const [parentId, args, kwargs = {}] = <any>nodeTuple;
+    //   [PARENT_ID, POSITIONAL_ARG_1, POSITIONAL_ARG_2, ..., {KEY_VALUE_ARGS}]
+    let kwargs;
+    const [parentId, ...args] = <any>nodeTuple;
+    if (args.length === _positionalCount) {
+      kwargs = {};
+    } else if (args.length === _positionalCount + 1) {
+      kwargs = args.pop();
+      if (typeof kwargs !== "object") {
+        throw new Error(
+          `unflattenSource: Expected dict as last tuple element: ${nodeTuple}`
+        );
+      }
+    } else {
+      throw new Error(`unflattenSource: unexpected tuple length: ${nodeTuple}`);
+    }
 
     // Free up some memory as we go
     nodeTuple[1] = null;
     if (nodeTuple[2] != null) {
       nodeTuple[2] = null;
     }
-    // console.log("flatten", parentId, args, kwargs)
-
     // We keep `kwargs` as our new node definition. Then we add all positional
     // values to this object:
     args.forEach((val: string, positionalIdx: number) => {
       kwargs[positionalShort[positionalIdx]] = val;
     });
+    args.length = 0;
 
     // Find the parent node. `null` means 'toplevel'. PARENT_ID may be the numeric
     // index of the source.children list. If PARENT_ID is a string, we search

package/src/debounce.ts

@@ -1,4 +1,9 @@
 /*!
+ * Wunderbaum - debounce.ts
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
+ * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
+ */
+/*
  * debounce & throttle, taken from https://github.com/lodash/lodash v4.17.21
  * MIT License: https://raw.githubusercontent.com/lodash/lodash/4.17.21-npm/LICENSE
  * Modified for TypeScript type annotations.

package/src/deferred.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - deferred
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 

package/src/drag_observer.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - drag_observer
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 

package/src/types.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - types
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 
@@ -22,7 +22,7 @@ export type SortOrderType = "asc" | "desc" | undefined;
  * or a boolean value that indicates if the default icon should be used or hidden.
  */
 export type IconOption = boolean | string;
-/** Show/hide tooltip or display a string. */
+/** Show/hide default tooltip or display a string. */
 export type TooltipOption = boolean | string;
 
 /*
@@ -93,7 +93,10 @@ export type NodeToDictCallback = (
   dict: WbNodeData,
   node: WunderbaumNode
 ) => NodeVisitResponse;
-/** A callback that receives a node instance and returns a string value. */
+/**
+ * A callback that receives a node instance and may returnsa `false` to prevent
+ * (de)selection.
+ */
 export type NodeSelectCallback = (node: WunderbaumNode) => boolean | void;
 
 /**
@@ -113,23 +116,56 @@ export type DynamicTooltipOption = TooltipOption | BoolOrStringOptionResolver;
 // type WithWildcards<T> = T & { [key: string]: unknown };
 /** A plain object (dictionary) that represents a node instance. */
 export interface WbNodeData {
+  /** Defines if the `selected` state is displayed as checkbox, radio button,
+   * or hidden.
+   * Defaults to {@link WunderbaumOptions.checkbox}.
+   */
   checkbox?: CheckboxOption;
+  /** Optional list of child nodes.
+   * If `children` is an empty array, the node is considered a leaf.
+   * If `lazy` is true and `children is undefined or null, the node, is
+   * considered unloaded. Otherwise, the node is considered a leaf.
+   */
   children?: Array<WbNodeData>;
+  /** Additional classes that are added to `<div class='wb-row'>`. */
   classes?: string;
+  /** Only show title in a single, merged column. */
   colspan?: boolean;
+  /** Expand this node. */
   expanded?: boolean;
+  /** Defaults to standard icons (doc, folder, folderOpen, ...)
+   * from {@link WunderbaumOptions.iconMap}.
+   * Can be overridden by {@link WunderbaumOptions.icon}.
+   */
   icon?: IconOption;
+  /** Tooltip for the node icon only. Defaults to {@link WunderbaumOptions.iconTooltip}. */
   iconTooltip?: TooltipOption;
+  /** The node's key. Must be unique for the whole tree. Defaults to a sequence number. */
   key?: string;
+  /** If true (and children are undefined or null), the node is considered lazy
+   * and {@link WunderbaumOptions.lazyLoad} is called when expanded.
+   */
   lazy?: boolean;
   /** Make child nodes single-select radio buttons. */
   radiogroup?: boolean;
+  /** Node's reference key. Unlike {@link WunderbaumNode.key}, this value
+   * may be non-unique. Nodes within the tree that share the same refKey are considered
+   * clones.
+   */
   refKey?: string;
+  /** The node's selection status, typically displayed as a checkbox. */
   selected?: boolean;
+  /** The node's status, typically displayed as merged single row.
+   * @see {@link Wunderbaum.setStatus}
+   */
   statusNodeType?: NodeStatusType;
+  /** The node's title. Will be html escaped to prevent XSS. */
   title: string;
+  /** Pass true to set node tooltip to the node's title. Defaults to {@link WunderbaumOptions.tooltip}. */
   tooltip?: TooltipOption;
+  /** Inherit shared settings from the matching entry in {@link WunderbaumOptions.types}. */
   type?: string;
+  /** Set to `true` to prevent selection. Defaults to {@link WunderbaumOptions.unselectable}. */
   unselectable?: boolean;
   /** @internal */
   _treeId?: string;
@@ -531,7 +567,7 @@ export enum ChangeType {
   scroll = "scroll",
 }
 
-/* Internal use. */
+/** @internal */
 export enum RenderFlag {
   clearMarkup = "clearMarkup",
   header = "header",
@@ -561,10 +597,14 @@ export enum NodeRegion {
 
 /** Initial navigation mode and possible transition. */
 export enum NavModeEnum {
-  startRow = "startRow", // Start with row mode, but allow cell-nav mode
-  cell = "cell", // Cell-nav mode only
-  startCell = "startCell", // Start in cell-nav mode, but allow row mode
-  row = "row", // Row mode only
+  /** Start with row mode, but allow cell-nav mode */
+  startRow = "startRow",
+  /** Cell-nav mode only */
+  cell = "cell",
+  /** Start in cell-nav mode, but allow row mode */
+  startCell = "startCell",
+  /** Row mode only */
+  row = "row",
 }
 
 /* -----------------------------------------------------------------------------
@@ -594,12 +634,34 @@ export interface ApplyCommandOptions {
 
 /** Possible values for {@link Wunderbaum.expandAll} and {@link WunderbaumNode.expandAll}. */
 export interface ExpandAllOptions {
-  /** Restrict expand level @default 99 */
-  depth?: number;
   /** Expand and load lazy nodes @default false  */
   loadLazy?: boolean;
-  /** Ignore `minExpandLevel` option @default false */
+  /** Unload lazily loaded children if any (if collapsing). @default false */
+  resetLazy?: boolean;
+  /** Ignore tree's `minExpandLevel` option @default false */
   force?: boolean;
+  /** Restrict expand level.
+   * Pass 0 to make only toplevel nodes visible, 1 to expand one level deeper, etc.
+   * @default unset (unlimited)
+   */
+  depth?: number;
+  /**
+   * Also collapse child nodes beyond the `depth` level.
+   * Otherwise only the `depth` level is collapsed and the expand state of the
+   * descendants is retained.
+   * Only in combination with collapse and `depth`.
+   * Expanding with `deep` option is not supported as recursion depth implied by
+   * the `depth` option. However a `deep` option will be considered if
+   * `collapseOthers` is set.
+   * @default false
+   */
+  deep?: boolean;
+  /**
+   * Expand up to level=depth and collapse all other branches.
+   * Only in combination with `flag == true`, `depth > 0`.
+   * @default false
+   */
+  collapseOthers?: boolean;
   /** Keep active node visible @default true */
   keepActiveNodeVisible?: boolean;
 }
@@ -723,7 +785,7 @@ export interface SetColumnOptions {
 
 /** Possible values for {@link WunderbaumNode.setExpanded} `options` argument. */
 export interface SetExpandedOptions {
-  /** Ignore {@link WunderbaumOptions.minExpandLevel}. @default false */
+  /** Ignore {@link WunderbaumOptions}.minExpandLevel. @default false */
   force?: boolean;
   /** Immediately update viewport (async otherwise). @default false */
   immediate?: boolean;
@@ -731,6 +793,8 @@ export interface SetExpandedOptions {
   noAnimation?: boolean;
   /** Do not send events. @default false */
   noEvents?: boolean;
+  /** Unload lazily loaded children if any (if collapsing). @default false */
+  resetLazy?: boolean;
   /** Scroll up to bring expanded nodes into viewport. @default false */
   scrollIntoView?: boolean;
 }
@@ -941,7 +1005,6 @@ export type InsertNodeType =
   | "after"
   | "prependChild"
   | "appendChild";
-// export type DndModeType = "before" | "after" | "over";
 
 export type DropEffectType = "none" | "copy" | "link" | "move";
 export type DropEffectAllowedType =

package/src/util.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - util
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 

package/src/wb_ext_dnd.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - ext-dnd
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 import * as util from "./util";
@@ -143,8 +143,8 @@ export class DndExtension extends WunderbaumExtension<DndOptionsType> {
       return dy < 0.25 * rowHeight
         ? "before"
         : dy > 0.75 * rowHeight
-        ? "after"
-        : "over";
+          ? "after"
+          : "over";
     } else if (allowed.size === 1 && allowed.has("over")) {
       return "over";
     } else {

package/src/wb_ext_edit.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - ext-edit
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 

package/src/wb_ext_filter.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - ext-filter
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 
@@ -177,7 +177,7 @@ export class FilterExtension extends WunderbaumExtension<FilterOptionsType> {
     }
 
     tree.filterMode = opts.mode;
-    // eslint-disable-next-line prefer-rest-params, prefer-spread
+    // eslint-disable-next-line prefer-rest-params
     this.lastFilterArgs = arguments;
 
     tree.element.classList.toggle("wb-ext-filter-hide", !!hideMode);

package/src/wb_ext_grid.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - ext-grid
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 import { Wunderbaum } from "./wunderbaum";

package/src/wb_ext_keynav.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - ext-keynav
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 

package/src/wb_ext_logger.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - ext-logger
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 

package/src/wb_extension_base.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - wb_extension_base
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 

package/src/wb_node.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - wunderbaum_node
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 
@@ -470,58 +470,78 @@ export class WunderbaumNode {
     this.tree._callMethod("edit.startEditTitle", this);
   }
 
-  /** Call `setExpanded()` on all descendant nodes. */
+  /**
+   * Call `setExpanded()` on all descendant nodes.
+   *
+   * @param flag true to expand, false to collapse.
+   * @param options Additional options.
+   * @see {@link Wunderbaum.expandAll}
+   * @see {@link WunderbaumNode.setExpanded}
+   */
   async expandAll(flag: boolean = true, options?: ExpandAllOptions) {
     const tree = this.tree;
-    const minExpandLevel = this.tree.options.minExpandLevel;
     const {
-      depth = 99,
-      loadLazy,
+      collapseOthers,
+      deep,
+      depth,
       force,
       keepActiveNodeVisible = true,
+      loadLazy,
+      resetLazy,
     } = options ?? {};
-
+    // limit expansion level to `depth` (or tree.minExpandLevel). Default: unlimited
+    const treeLevel = this.tree.options.minExpandLevel || null; // 0 -> null
+    const minLevel = depth ?? (force ? null : treeLevel);
     const expandOpts = {
-      scrollIntoView: false, // don't scroll very node on iteration
+      deep: deep,
       force: force,
       loadLazy: loadLazy,
+      resetLazy: resetLazy,
+      scrollIntoView: false, // don't scroll every node while iterating
     };
 
-    // this.logInfo(`expandAll(${flag})`);
+    this.logInfo(`expandAll(${flag}, depth=${depth}, minLevel=${minLevel})`);
+
+    util.assert(
+      !(flag && deep != null && !collapseOthers),
+      "Expanding with `deep` option is not supported (implied by the `depth` option)."
+    );
+
     // Expand all direct children in parallel:
-    async function _iter(n: WunderbaumNode, level: number | null) {
-      // n.logInfo(`  _iter(${level})`);
-      if (level === 0) {
-        return;
-      }
-      // if (!flag && minExpandLevel && !force && n.getLevel() <= minExpandLevel) {
-      //   return; // Do not collapse until minExpandLevel
-      // }
-      const level_1 = level == null ? null : level - 1;
+    async function _iter(n: WunderbaumNode, level: number) {
+      // n.logInfo(`  _iter(level=${level})`);
       const promises: Promise<unknown>[] = [];
       n.children?.forEach((cn) => {
         if (flag) {
-          if (!cn.expanded && (cn.children || (loadLazy && cn.lazy))) {
+          if (
+            !cn.expanded &&
+            (minLevel == null || level < minLevel) &&
+            (cn.children || (loadLazy && cn.lazy))
+          ) {
             // Node is collapsed and may be expanded (i.e. has children or is lazy)
             // Expanding may be async, so we store the promise.
             // Also the recursion is delayed until expansion finished.
             const p = cn.setExpanded(true, expandOpts);
             promises.push(p);
-            p.then(async () => {
-              await _iter(cn, level_1);
-            });
+            if (depth == null) {
+              p.then(async () => {
+                await _iter(cn, level + 1);
+              });
+            }
           } else {
             // We don't expand the node, but still visit descendants.
             // There we may find lazy nodes, so we
-            promises.push(_iter(cn, level_1));
+            promises.push(_iter(cn, level + 1));
           }
         } else {
           // Collapsing is always synchronous, so no promises required
-          if (!minExpandLevel || force || cn.getLevel() > minExpandLevel) {
-            // Do not collapse until minExpandLevel
+          // Do not collapse until minExpandLevel
+          if (minLevel == null || level >= minLevel) {
             cn.setExpanded(false, expandOpts);
           }
-          _iter(cn, level_1); // recursion, even if cn was already collapsed
+          if ((minLevel != null && level < minLevel) || deep) {
+            _iter(cn, level + 1); // recursion, even if cn was already collapsed
+          }
         }
       });
       return new Promise((resolve) => {
@@ -531,10 +551,20 @@ export class WunderbaumNode {
       });
     }
 
-    const tag = tree.logTime(`${this}.expandAll(${flag})`);
+    const tag = tree.logTime(`${this}.expandAll(${flag}, depth=${depth})`);
     try {
       tree.enableUpdate(false);
-      await _iter(this, depth);
+
+      await _iter(this, 0);
+
+      if (collapseOthers) {
+        util.assert(flag, "Option `collapseOthers` requires flag=true");
+        util.assert(
+          minLevel != null,
+          "Option `collapseOthers` requires `depth` or `minExpandLevel`"
+        );
+        this.expandAll(false, { depth: minLevel! });
+      }
     } finally {
       tree.enableUpdate(true);
       tree.logTimeEnd(tag);
@@ -2199,7 +2229,7 @@ export class WunderbaumNode {
     const colIdx = options?.colIdx; // Default: null
     const edit = options?.edit; // Default: false
 
-    util.assert(!colIdx || tree.isCellNav(), "colIdx requires cellNav");
+    // util.assert(!colIdx || tree.isCellNav(), "colIdx requires cellNav");
     util.assert(!edit || colIdx != null, "edit requires colIdx");
 
     if (!noEvents) {
@@ -2257,7 +2287,7 @@ export class WunderbaumNode {
    * Expand or collapse this node.
    */
   async setExpanded(flag: boolean = true, options?: SetExpandedOptions) {
-    const { force, scrollIntoView, immediate } = options ?? {};
+    const { force, scrollIntoView, immediate, resetLazy } = options ?? {};
     const sendEvents = !options?.noEvents; // Default: send events
     if (
       !flag &&
@@ -2284,6 +2314,8 @@ export class WunderbaumNode {
     }
     if (flag && this.lazy && this.children == null) {
       await this.loadLazy();
+    } else if (!flag && resetLazy && this.lazy && this.children) {
+      this.resetLazy();
     }
     this.expanded = flag;
     const updateOpts = { immediate: immediate };
@@ -2405,7 +2437,8 @@ export class WunderbaumNode {
       case undefined:
         changed = this.selected || !this._partsel;
         this.selected = false;
-        this._partsel = true;
+        // #110: end nodess cannot have a `_partsel` flag
+        this._partsel = this.hasChildren() ? true : false;
         break;
       default:
         util.error(`Invalid state: ${state}`);

package/src/wb_options.ts

@@ -1,6 +1,6 @@
 /*!
  * Wunderbaum - utils
- * Copyright (c) 2021-2024, Martin Wendt. Released under the MIT license.
+ * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
  * @VERSION, @DATE (https://github.com/mar10/wunderbaum)
  */
 
@@ -113,6 +113,14 @@ export interface WunderbaumOptions {
   skeleton?: boolean;
   /**
    * Translation map for some system messages.
+   * Default:
+   * ```js
+   * strings: {
+   *   loading: "Loading...",
+   *   loadError: "Error",
+   *   noData: "No data",
+   * }
+   * ```
    */
   strings?: any; //[key: string] string;
   /**