wunderbaum 0.13.0 → 0.14.1

package/dist/wunderbaum.esm.js

@@ -1,7 +1,7 @@
 /*!
  * Wunderbaum - debounce.ts
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 /*
  * debounce & throttle, taken from https://github.com/lodash/lodash v4.17.21
@@ -293,7 +293,7 @@ function throttle(func, wait = 0, options = {}) {
 /*!
  * Wunderbaum - util
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 /** @module util */
 /** Readable names for `MouseEvent.button` */
@@ -443,7 +443,7 @@ function each(obj, callback) {
     }
     return obj;
 }
-/** Shortcut for `throw new Error(msg)`.*/
+/** Shortcut for `throw new Error(msg)`. */
 function error(msg) {
     throw new Error(msg);
 }
@@ -958,6 +958,10 @@ function toPixel(...defaults) {
     }
     throw new Error(`Expected a string like '123px': ${defaults}`);
 }
+/** Cast any value to <T>. */
+function unsafeCast(value) {
+    return value;
+}
 /** Return the the boolean value of the first non-null element.
  * Example:
  * ```js
@@ -1031,7 +1035,7 @@ function adaptiveThrottle(callback, options) {
     const throttledFn = (...args) => {
         if (waiting) {
             pendingArgs = args;
-            // console.log(`adaptiveThrottle() queing request #${waiting}...`, args);
+            // console.log(`adaptiveThrottle() queueing request #${waiting}...`, args);
             waiting += 1;
         }
         else {
@@ -1086,6 +1090,60 @@ function adaptiveThrottle(callback, options) {
     };
     return throttledFn;
 }
+/**
+ * MurmurHash3 implementation for strings.
+ * @param key The input string to hash.
+ * @param asString Optional convert result to zero-padded string of 8 characters.
+ * @param seed Optional seed value.
+ * @returns A 32-bit hash as a number or string.
+ */
+function murmurHash3(key, asString = true, seed = 0) {
+    let h1 = seed;
+    const remainder = key.length & 3; // key.length % 4
+    const bytes = key.length - remainder;
+    const c1 = 0xcc9e2d51;
+    const c2 = 0x1b873593;
+    let i = 0;
+    while (i < bytes) {
+        let k1 = (key.charCodeAt(i) & 0xff) |
+            ((key.charCodeAt(++i) & 0xff) << 8) |
+            ((key.charCodeAt(++i) & 0xff) << 16) |
+            ((key.charCodeAt(++i) & 0xff) << 24);
+        ++i;
+        k1 = Math.imul(k1, c1);
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = Math.imul(k1, c2);
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1 = Math.imul(h1, 5) + 0xe6546b64;
+    }
+    let k1 = 0;
+    switch (remainder) {
+        case 3:
+            k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+        // fall through
+        case 2:
+            k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+        // fall through
+        case 1:
+            k1 ^= key.charCodeAt(i) & 0xff;
+            k1 = Math.imul(k1, c1);
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = Math.imul(k1, c2);
+            h1 ^= k1;
+    }
+    h1 ^= key.length;
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 0x85ebca6b);
+    h1 ^= h1 >>> 13;
+    h1 = Math.imul(h1, 0xc2b2ae35);
+    h1 ^= h1 >>> 16;
+    if (asString) {
+        // Convert to 8 digit hex string
+        return (h1 >>> 0).toString(16).padStart(8, "0");
+    }
+    return h1 >>> 0; // Convert to unsigned 32-bit integer
+}
 
 var util = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1116,6 +1174,7 @@ var util = /*#__PURE__*/Object.freeze({
     isFunction: isFunction,
     isMac: isMac,
     isPlainObject: isPlainObject,
+    murmurHash3: murmurHash3,
     noop: noop,
     onEvent: onEvent,
     overrideMethod: overrideMethod,
@@ -1129,13 +1188,14 @@ var util = /*#__PURE__*/Object.freeze({
     toPixel: toPixel,
     toSet: toSet,
     toggleCheckbox: toggleCheckbox,
-    type: type
+    type: type,
+    unsafeCast: unsafeCast
 });
 
 /*!
  * Wunderbaum - types
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 /**
  * Possible values for {@link WunderbaumNode.update} and {@link Wunderbaum.update}.
@@ -1203,7 +1263,7 @@ var NavModeEnum;
 /*!
  * Wunderbaum - wb_extension_base
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 class WunderbaumExtension {
     constructor(tree, id, defaults) {
@@ -1262,7 +1322,7 @@ class WunderbaumExtension {
 /*!
  * Wunderbaum - ext-filter
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 const START_MARKER = "\uFFF7";
 const END_MARKER = "\uFFF8";
@@ -1550,6 +1610,10 @@ class FilterExtension extends WunderbaumExtension {
      */
     filterBranches(filter, options) {
         assert(options.matchBranch === undefined, "filterBranches() is deprecated.");
+        this.tree.logDeprecate("filterBranches()", {
+            since: "0.9.0",
+            hint: "Use `filterNodes` instead and set `options.matchBranch: true`",
+        });
         options.matchBranch = true;
         return this._applyFilterNoUpdate(filter, options);
     }
@@ -1614,7 +1678,7 @@ class FilterExtension extends WunderbaumExtension {
     }
 }
 /**
- * @description Marks the matching charecters of `text` either by `mark` or
+ * @description Marks the matching characters of `text` either by `mark` or
  * by exotic*Chars (if `escapeTitles` is `true`) based on `matches`
  * which is an array of matching groups.
  * @param {string} text
@@ -1653,7 +1717,7 @@ function _markFuzzyMatchedChars(text, matches, escapeTitles = true) {
 /*!
  * Wunderbaum - ext-keynav
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 const QUICKSEARCH_DELAY = 500;
 class KeynavExtension extends WunderbaumExtension {
@@ -2017,7 +2081,7 @@ class KeynavExtension extends WunderbaumExtension {
 /*!
  * Wunderbaum - ext-logger
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 class LoggerExtension extends WunderbaumExtension {
     constructor(tree) {
@@ -2059,7 +2123,7 @@ class LoggerExtension extends WunderbaumExtension {
 /*!
  * Wunderbaum - ext-dnd
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 const nodeMimeType = "application/x-wunderbaum-node";
 class DndExtension extends WunderbaumExtension {
@@ -2295,7 +2359,6 @@ class DndExtension extends WunderbaumExtension {
      */
     onDragEvent(e) {
         var _a;
-        // const tree = this.tree;
         const dndOpts = this.treeOpts.dnd;
         const srcNode = Wunderbaum.getNode(e);
         if (!srcNode) {
@@ -2321,7 +2384,7 @@ class DndExtension extends WunderbaumExtension {
                 return false;
             }
             const nodeData = srcNode.toDict(true, (n) => {
-                // We don't want to re-use the key on drop:
+                // We don't want to reuse the key on drop:
                 n._orgKey = n.key;
                 delete n.key;
             });
@@ -2383,6 +2446,7 @@ class DndExtension extends WunderbaumExtension {
         };
         if (!targetNode) {
             this._leaveNode();
+            e.preventDefault(); // Don't open file in browser when dropped in empty area
             return;
         }
         if (["drop"].includes(e.type)) {
@@ -2488,19 +2552,20 @@ class DndExtension extends WunderbaumExtension {
             nodeData = nodeData ? JSON.parse(nodeData) : null;
             const srcNode = this.srcNode;
             const lastDropEffect = this.lastDropEffect;
-            setTimeout(() => {
-                // Decouple this call, because drop actions may prevent the dragend event
-                // from being fired on some browsers
-                targetNode._callEvent("dnd.drop", {
-                    event: e,
-                    region: region,
-                    suggestedDropMode: region === "over" ? "appendChild" : region,
-                    suggestedDropEffect: lastDropEffect,
-                    // suggestedDropEffect: e.dataTransfer?.dropEffect,
-                    sourceNode: srcNode,
-                    sourceNodeData: nodeData,
-                });
-            }, 10);
+            /* Before v0.14.0, we decoupled `_callEvent` like so:
+                 Decouple this call, because drop actions may prevent the dragend
+                 event from being fired on some browsers.
+                 setTimeout(() => {...}, 10);
+              however this made e.dataTransfer.items inaccessible */
+            targetNode._callEvent("dnd.drop", {
+                event: e,
+                region: region,
+                suggestedDropMode: region === "over" ? "appendChild" : region,
+                suggestedDropEffect: lastDropEffect,
+                sourceNode: srcNode,
+                sourceNodeData: nodeData,
+                dataTransfer: e.dataTransfer,
+            });
         }
         return false;
     }
@@ -2509,7 +2574,7 @@ class DndExtension extends WunderbaumExtension {
 /*!
  * Wunderbaum - drag_observer
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 /**
  * Convert mouse- and touch events to 'dragstart', 'drag', and 'dragstop'.
@@ -2658,7 +2723,7 @@ class DragObserver {
 /*!
  * Wunderbaum - common
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 const DEFAULT_DEBUGLEVEL = 3; // Replaced by rollup script
 /**
@@ -2678,12 +2743,18 @@ const TITLE_SPAN_PAD_Y = 7;
 const RENDER_MAX_PREFETCH = 5;
 /** Minimum column width if not set otherwise. */
 const DEFAULT_MIN_COL_WIDTH = 4;
+/**
+ * A value for `node.type` that by convention may be used to mark a node as directory.
+ * It may be used to sort 'directories' to the top.
+ */
+const NODE_TYPE_FOLDER = "folder";
 /** Regular expression to detect if a string describes an image URL (in contrast
  * to a class name). Strings are considered image urls if they contain '.' or '/'.
+ * `<` is ignored, because it is probably an html tag.
  */
-const TEST_IMG = new RegExp(/\.|\//);
-// export const RECURSIVE_REQUEST_ERROR = "$recursive_request";
-// export const INVALID_REQUEST_TARGET_ERROR = "$request_target_invalid";
+const TEST_FILE_PATH = /^(?!.*<).*[/.]/;
+/** Regular expression to detect if a string describes an HTML element. */
+const TEST_HTML = /</;
 /**
  * Default node icons for icon libraries
  *
@@ -2691,7 +2762,7 @@ const TEST_IMG = new RegExp(/\.|\//);
  *  - 'fontawesome6' {@link https://fontawesome.com/icons}
  *
  */
-const iconMaps = {
+const defaultIconMaps = {
     bootstrap: {
         error: "bi bi-exclamation-triangle",
         // loading: "bi bi-hourglass-split wb-busy",
@@ -2739,7 +2810,7 @@ const iconMaps = {
         radioChecked: "fa-solid fa-circle",
         radioUnchecked: "fa-regular fa-circle",
         radioUnknown: "fa-regular fa-circle-question",
-        folder: "fa-solid fa-folder-closed",
+        folder: "fa-regular fa-folder-closed",
         folderOpen: "fa-regular fa-folder-open",
         folderLazy: "fa-solid fa-folder-plus",
         doc: "fa-regular fa-file",
@@ -2812,12 +2883,20 @@ function makeNodeTitleStartMatcher(s) {
         return reMatch.test(node.title);
     };
 }
-/** Compare two nodes by title (case-insensitive). */
+/** Compare two nodes by title (case-insensitive).
+ * @deprecated Use `key` option instead of `cmp` in sort methods.
+ */
 function nodeTitleSorter(a, b) {
     const x = a.title.toLowerCase();
     const y = b.title.toLowerCase();
     return x === y ? 0 : x > y ? 1 : -1;
 }
+// /** Compare nodes by title (case-insensitive). */
+// export function nodeTitleKeyGetter(
+//   node: WunderbaumNode
+// ): string | number | Array<any> {
+//   return node.title.toLowerCase();
+// }
 /**
  * Convert 'flat' to 'nested' format.
  *
@@ -3008,7 +3087,7 @@ function decompressSourceData(source) {
 /*!
  * Wunderbaum - ext-grid
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 class GridExtension extends WunderbaumExtension {
     constructor(tree) {
@@ -3068,7 +3147,7 @@ class GridExtension extends WunderbaumExtension {
         super.init();
     }
     /**
-     * Hanldes drag and sragstop events for column resizing.
+     * Handles drag and sragstop events for column resizing.
      */
     handleDrag(e) {
         const custom = e.customData;
@@ -3099,7 +3178,7 @@ class GridExtension extends WunderbaumExtension {
 /*!
  * Wunderbaum - deferred
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 /**
  * Implement a ES6 Promise, that exposes a resolve() and reject() method.
@@ -3152,7 +3231,7 @@ class Deferred {
 /*!
  * Wunderbaum - wunderbaum_node
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 /** WunderbaumNode properties that can be passed with source data.
  * (Any other source properties will be stored as `node.data.PROP`.)
@@ -3203,7 +3282,7 @@ NODE_DICT_PROPS.delete("unselectable");
  */
 class WunderbaumNode {
     constructor(tree, parent, data) {
-        var _a, _b;
+        var _a;
         /** Reference key. Unlike {@link key}, a `refKey` may occur multiple
          * times within a tree (in this case we have 'clone nodes').
          * @see Use {@link setKey} to modify.
@@ -3233,8 +3312,8 @@ class WunderbaumNode {
         assert(!data.children, "'children' not allowed here");
         this.tree = tree;
         this.parent = parent;
-        this.key = "" + ((_a = data.key) !== null && _a !== void 0 ? _a : ++WunderbaumNode.sequence);
-        this.title = "" + ((_b = data.title) !== null && _b !== void 0 ? _b : "<" + this.key + ">");
+        this.key = tree._calculateKey(data, parent);
+        this.title = "" + ((_a = data.title) !== null && _a !== void 0 ? _a : "<" + this.key + ">");
         this.expanded = !!data.expanded;
         this.lazy = !!data.lazy;
         // We set the following node properties only if a matching data value is
@@ -3251,7 +3330,9 @@ class WunderbaumNode {
             : 0;
         data.colspan != null ? (this.colspan = !!data.colspan) : 0;
         // Selection
-        data.checkbox != null ? intToBool(data.checkbox) : 0;
+        data.checkbox != null
+            ? (this.checkbox = intToBool(data.checkbox))
+            : 0;
         data.radiogroup != null ? (this.radiogroup = !!data.radiogroup) : 0;
         data.selected != null ? (this.selected = !!data.selected) : 0;
         data.unselectable != null ? (this.unselectable = !!data.unselectable) : 0;
@@ -3355,8 +3436,14 @@ class WunderbaumNode {
             const forceExpand = applyMinExpanLevel && _level < tree.options.minExpandLevel;
             for (const child of nodeData) {
                 const subChildren = child.children;
+                // Remove children property from source data because it should not be
+                // passed to the constructor of WunderbaumNode:
                 delete child.children;
                 const n = new WunderbaumNode(tree, this, child);
+                // Set `children` property again, so it can be used in `reload()`
+                if (subChildren != null) {
+                    child.children = subChildren;
+                }
                 if (forceExpand && !n.isUnloaded()) {
                     n.expanded = true;
                 }
@@ -3772,15 +3859,12 @@ class WunderbaumNode {
         }
         return l;
     }
-    /** Return a string representing the hierachical node path, e.g. "a/b/c".
+    /** Return a string representing the hierarchical node path, e.g. "a/b/c".
      * @param includeSelf
      * @param part property name or callback
      * @param separator
      */
     getPath(includeSelf = true, part = "title", separator = "/") {
-        // includeSelf = includeSelf !== false;
-        // part = part || "title";
-        // separator = separator || "/";
         let val;
         const path = [];
         const isFunc = typeof part === "function";
@@ -3795,7 +3879,7 @@ class WunderbaumNode {
         }, includeSelf);
         return path.join(separator);
     }
-    /** Return the preceeding node (under the same parent) or null. */
+    /** Return the preceding node (under the same parent) or null. */
     getPrevSibling() {
         const ac = this.parent.children;
         const idx = ac.indexOf(this);
@@ -3824,7 +3908,7 @@ class WunderbaumNode {
     hasClass(className) {
         return this.classes ? this.classes.has(className) : false;
     }
-    /** Return true if node ist the currently focused node. @since 0.9.0 */
+    /** Return true if node is the currently focused node. @since 0.9.0 */
     hasFocus() {
         return this.tree.focusNode === this;
     }
@@ -3879,7 +3963,7 @@ class WunderbaumNode {
      * an expand operation is currently possible.
      */
     isExpandable(andCollapsed = false) {
-        // `false` is never expandable (unoffical)
+        // `false` is never expandable (unofficial)
         if ((andCollapsed && this.expanded) || this.children === false) {
             return false;
         }
@@ -3942,11 +4026,11 @@ class WunderbaumNode {
     isPartsel() {
         return !this.selected && !!this._partsel;
     }
-    /** Return true if this node has DOM representaion, i.e. is displayed in the viewport. */
+    /** Return true if this node has DOM representation, i.e. is displayed in the viewport. */
     isRadio() {
         return !!this.parent.radiogroup || this.getOption("checkbox") === "radio";
     }
-    /** Return true if this node has DOM representaion, i.e. is displayed in the viewport. */
+    /** Return true if this node has DOM representation, i.e. is displayed in the viewport. */
     isRendered() {
         return !!this._rowElem;
     }
@@ -4701,9 +4785,9 @@ class WunderbaumNode {
         const typeInfo = this.type ? tree.types[this.type] : null;
         const rowDiv = this._rowElem;
         // Row markup already exists
-        const nodeElem = rowDiv.querySelector("span.wb-node");
-        const expanderSpan = nodeElem.querySelector("i.wb-expander");
-        const checkboxSpan = nodeElem.querySelector("i.wb-checkbox");
+        const nodeSpan = rowDiv.querySelector("span.wb-node");
+        const expanderElem = nodeSpan.querySelector("i.wb-expander");
+        const checkboxElem = nodeSpan.querySelector("i.wb-checkbox");
         const rowClasses = ["wb-row"];
         this.expanded ? rowClasses.push("wb-expanded") : 0;
         this.lazy ? rowClasses.push("wb-lazy") : 0;
@@ -4728,7 +4812,7 @@ class WunderbaumNode {
         if (typeInfo && typeInfo.classes) {
             rowDiv.classList.add(...typeInfo.classes);
         }
-        if (expanderSpan) {
+        if (expanderElem) {
             let image = null;
             if (this._isLoading) {
                 image = iconMap.loading;
@@ -4745,16 +4829,20 @@ class WunderbaumNode {
                 image = iconMap.expanderLazy;
             }
             if (image == null) {
-                expanderSpan.classList.add("wb-indent");
+                expanderElem.className = "wb-expander";
+                expanderElem.classList.add("wb-indent");
+            }
+            else if (TEST_HTML.test(image)) {
+                expanderElem.replaceWith(elemFromHtml(image));
             }
-            else if (TEST_IMG.test(image)) {
-                expanderSpan.style.backgroundImage = `url('${image}')`;
+            else if (TEST_FILE_PATH.test(image)) {
+                expanderElem.style.backgroundImage = `url('${image}')`;
             }
             else {
-                expanderSpan.className = "wb-expander " + image;
+                expanderElem.className = "wb-expander " + image;
             }
         }
-        if (checkboxSpan) {
+        if (checkboxElem) {
             let cbclass = "wb-checkbox ";
             if (this.isRadio()) {
                 cbclass += "wb-radio ";
@@ -4778,7 +4866,7 @@ class WunderbaumNode {
                     cbclass += iconMap.checkUnchecked;
                 }
             }
-            checkboxSpan.className = cbclass;
+            checkboxElem.className = cbclass;
         }
         // Fix active cell in cell-nav mode
         if (!opts.isNew) {
@@ -4788,9 +4876,9 @@ class WunderbaumNode {
                 colSpan.classList.remove("wb-error", "wb-invalid");
             }
             // Update icon (if not opts.isNew, which would rebuild markup anyway)
-            const iconSpan = nodeElem.querySelector("i.wb-icon");
+            const iconSpan = nodeSpan.querySelector("i.wb-icon");
             if (iconSpan) {
-                this._createIcon(nodeElem, iconSpan, !expanderSpan);
+                this._createIcon(nodeSpan, iconSpan, !expanderElem);
             }
         }
         // Adjust column width
@@ -5095,6 +5183,32 @@ class WunderbaumNode {
     setKey(key, refKey) {
         throw new Error("Not yet implemented");
     }
+    // /**
+    //  * Calculate a *stable*, unique key for this node from its refKey (or title).
+    //  * We also add information from the parent, because a refKey may occur multiple
+    //  * times in a tree.
+    //  */
+    // calcUniqueKey() {
+    //   // Assuming that the parent's key was calculated the same way, we implicitly
+    //   // involve the whole refKey-path:
+    //   const s = this.key + (this.refKey || this.title);
+    //   // 32-bit has a high probability of collisions, so we pump up to 64-bit
+    //   // https://security.stackexchange.com/q/209882/207588
+    //   const h1 = util.murmurHash3(s, true);
+    //   return "id_" + h1 + util.murmurHash3(h1 + s, true);
+    //   // const l = [];
+    //   // // eslint-disable-next-line  @typescript-eslint/no-this-alias
+    //   // let node: WunderbaumNode = this;
+    //   // while (node.parent) {
+    //   //   l.unshift(node.refKey || node.key);
+    //   //   node = node.parent;
+    //   // }
+    //   // const path = l.join("/");
+    //   // 32-bit has a high probability of collisions, so we pump up to 64-bit
+    //   // https://security.stackexchange.com/q/209882/207588
+    //   // const h1 = util.murmurHash3(path, true);
+    //   // return "id_" + h1 + util.murmurHash3(h1 + path, true);
+    // }
     /**
      * Trigger a repaint, typically after a status or data change.
      *
@@ -5126,6 +5240,23 @@ class WunderbaumNode {
         });
         return nodeList;
     }
+    /**
+     * Return an array of refKey values.
+     *
+     * RefKeys are unique identifiers for a node data, and are used to identify
+     * clones.
+     * If more than one node has the same refKey, it is only returned once.
+     * @param selected if true, only return refKeys of selected nodes.
+     */
+    getRefKeys(selected = false) {
+        const refKeys = new Set();
+        this.visit((node) => {
+            if (node.refKey != null && (!selected || node.selected)) {
+                refKeys.add(node.refKey);
+            }
+        });
+        return Array.from(refKeys);
+    }
     /** Toggle the check/uncheck state. */
     toggleSelected(options) {
         let flag = this.isSelected();
@@ -5305,9 +5436,11 @@ class WunderbaumNode {
                 if (selectMode === "hier") {
                     this.fixSelection3AfterClick();
                 }
-                else if (selectMode === "single") {
+                else if (selectMode === "single" && flag) {
                     tree.visit((n) => {
-                        n.selected = false;
+                        if (n !== this) {
+                            n.selected = false;
+                        }
                     });
                 }
             }
@@ -5409,30 +5542,16 @@ class WunderbaumNode {
         this.tooltip = tooltip;
         this.update();
     }
-    _sortChildren(cmp, deep) {
-        const cl = this.children;
-        if (!cl) {
-            return;
-        }
-        cl.sort(cmp);
-        if (deep) {
-            for (let i = 0, l = cl.length; i < l; i++) {
-                if (cl[i].children) {
-                    cl[i]._sortChildren(cmp, deep);
-                }
-            }
-        }
-    }
     /**
      * Sort child list by title or custom criteria.
      * @param {function} cmp custom compare function(a, b) that returns -1, 0, or 1
      *    (defaults to sorting by title).
      * @param {boolean} deep pass true to sort all descendant nodes recursively
+     * @deprecated use {@link sort}
      */
     sortChildren(cmp = nodeTitleSorter, deep = false) {
-        this._sortChildren(cmp || nodeTitleSorter, deep);
-        this.tree.update(ChangeType.structure);
-        // this.triggerModify("sort"); // TODO
+        this.tree.logDeprecate("node.sortChildren()", { since: "0.14.0" });
+        return this.sort({ cmp: cmp ? cmp : undefined, deep: deep });
     }
     /**
      * Renumber nodes `_nativeIndex`. This is useful to allow to restore the
@@ -5454,74 +5573,142 @@ class WunderbaumNode {
     /**
      * Convenience method to implement column sorting.
      * @since 0.11.0
+     * @deprecated use {@link sort}
      */
     sortByProperty(options) {
-        var _a, _b, _c;
-        const { caseInsensitive = true, deep = true, nativeOrderPropName = "_nativeIndex", updateColInfo = false, } = options;
-        let order;
-        let colDef;
+        this.tree.logDeprecate("node.sortByProperty()", { since: "0.14.0" });
+        return this.sort(options);
+    }
+    /**
+     * Implement column sorting.
+     * @since 0.14.0
+     */
+    sort(options) {
+        const tree = this.tree;
+        let { propName = undefined, deep = true, key = undefined, order = undefined, caseInsensitive = true, cmp = undefined, 
+        // Support click on column sort header:
+        updateColInfo = false, nativeOrderPropName = "_nativeIndex", colId = undefined, } = options;
+        propName !== null && propName !== void 0 ? propName : (propName = colId);
+        if (propName === "*") {
+            propName = "title";
+        }
+        const isFolder = tree.options.sortFoldersFirst === true
+            ? (node) => node.hasChildren() !== false || node.type === NODE_TYPE_FOLDER
+            : tree.options.sortFoldersFirst;
         if (updateColInfo) {
-            colDef = this.tree["_columnsById"][options.colId];
+            const colDef = this.tree["_columnsById"][options.colId];
             assert(colDef, `Invalid colId specified: ${options.colId}`);
-            order =
-                (_a = options.order) !== null && _a !== void 0 ? _a : rotate(colDef.sortOrder, ["asc", "desc", undefined]);
+            order !== null && order !== void 0 ? order : (order = rotate(colDef.sortOrder, ["asc", "desc", undefined]));
             for (const col of this.tree.columns) {
                 col.sortOrder = col === colDef ? order : undefined;
             }
+            if (order === undefined) {
+                propName = nativeOrderPropName;
+                order = "asc";
+            }
             this.tree.update(ChangeType.colStructure);
         }
         else {
-            order = (_b = options.order) !== null && _b !== void 0 ? _b : "asc";
+            propName !== null && propName !== void 0 ? propName : (propName = "title");
+            order !== null && order !== void 0 ? order : (order = "asc");
+        }
+        this.logDebug(`sort(), propName=${propName}, ${order}`, options);
+        assert(propName || cmp || key, "No `propName` or `key` specified");
+        // Define a key callback from the parameters we have
+        if (key == null && cmp == null) {
+            key = (node) => {
+                let val;
+                if (NODE_DICT_PROPS.has(propName)) {
+                    val = node[propName];
+                }
+                else {
+                    val = node.data[propName];
+                }
+                if (caseInsensitive && typeof val === "string") {
+                    val = val.toLowerCase();
+                }
+                return val;
+            };
         }
-        let propName = (_c = options.propName) !== null && _c !== void 0 ? _c : (options.colId || "");
-        if (propName === "*") {
-            propName = "title";
+        // Define a compare callback that uses the key callback
+        if (cmp) {
+            assert(!key, "`key` and `cmp` are mutually exclusive");
+            tree.logDeprecate("SortOptions.cmp", {
+                since: "0.14.0",
+                hint: "use the `key` callback instead",
+            });
         }
-        if (order == null) {
-            propName = nativeOrderPropName;
-            order = "asc";
+        else {
+            if (options.propName || options.caseInsensitive) {
+                tree.logWarn("sort(): ignoring propName, caseInsensitive");
+            }
+            cmp = (a, b) => {
+                if (isFolder) {
+                    const isFolderA = isFolder(a);
+                    if (isFolderA !== isFolder(b)) {
+                        return isFolderA ? -1 : 1;
+                    }
+                }
+                let x = key(a);
+                let y = key(b);
+                // Assure we have reasonable comparisons with null values:
+                if (x == null) {
+                    x = typeof y === "string" ? "" : 0;
+                }
+                else if (typeof x === "boolean") {
+                    x = x ? 1 : 0;
+                }
+                if (y == null) {
+                    y = typeof x === "string" ? "" : 0;
+                }
+                else if (typeof y === "boolean") {
+                    y = y ? 1 : 0;
+                }
+                if (order === "desc") {
+                    return x === y ? 0 : x > y ? -1 : 1;
+                }
+                return x === y ? 0 : x > y ? 1 : -1;
+            };
         }
-        this.logDebug(`sortByProperty(), propName=${propName}, ${order}`, options);
-        assert(propName, "No property name specified");
-        const cmp = (a, b) => {
-            let av, bv;
-            if (NODE_DICT_PROPS.has(propName)) {
-                av = a[propName];
-                bv = b[propName];
-            }
-            else {
-                av = a.data[propName];
-                bv = b.data[propName];
-            }
-            if (av == null && bv == null) {
-                return 0;
-            }
-            if (av == null) {
-                av = typeof bv === "string" ? "" : 0;
-            }
-            else if (typeof av === "boolean") {
-                av = av ? 1 : 0;
-            }
-            if (bv == null) {
-                bv = typeof av === "string" ? "" : 0;
-            }
-            else if (typeof bv === "boolean") {
-                bv = bv ? 1 : 0;
+        function _sortChildren(cl) {
+            if (!cl) {
+                return;
             }
-            if (caseInsensitive) {
-                if (typeof av === "string") {
-                    av = av.toLowerCase();
-                }
-                if (typeof bv === "string") {
-                    bv = bv.toLowerCase();
+            cl.sort(cmp);
+            if (deep) {
+                for (let i = 0, l = cl.length; i < l; i++) {
+                    if (cl[i].children) {
+                        _sortChildren(cl[i].children);
+                    }
                 }
             }
-            if (order === "desc") {
-                return av === bv ? 0 : av > bv ? -1 : 1;
+        }
+        if (this.children) {
+            _sortChildren(this.children);
+        }
+        this.tree.update(ChangeType.structure);
+        // this.triggerModify("sort"); // TODO
+    }
+    /**
+     * Re-apply current sorting if any (use after lazy load).
+     * Example:
+     * ```js
+     * load: function (e) {
+     *   // Whe loading a lazy branch, apply current sort order if any
+     *   e.node.resort();
+     * },
+     * ```
+     * @since 0.14.0
+     */
+    resort(options = {}) {
+        for (const colDef of this.tree.columns) {
+            if (colDef.sortOrder) {
+                options.colId = colDef.id;
+                options.order = colDef.sortOrder;
+                this.sort(options);
+                break;
             }
-            return av === bv ? 0 : av > bv ? 1 : -1;
-        };
-        return this.sortChildren(cmp, deep);
+        }
     }
     /**
      * Trigger `modifyChild` event on a parent to signal that a child was modified.
@@ -5558,7 +5745,8 @@ class WunderbaumNode {
      * @param {function} callback the callback function.
      *     Return false to stop iteration, return "skip" to skip this node and
      *     its children only.
-     * @see {@link IterableIterator<WunderbaumNode>}, {@link Wunderbaum.visit}.
+     * @see `wb_node.WunderbaumNode.IterableIterator<WunderbaumNode>`
+     * @see {@link Wunderbaum.visit}.
      */
     visit(callback, includeSelf = false) {
         let res = true;
@@ -5631,7 +5819,7 @@ WunderbaumNode.sequence = 0;
 /*!
  * Wunderbaum - ext-edit
  * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
- * v0.13.0, Sat, 08 Mar 2025 14:16:31 GMT (https://github.com/mar10/wunderbaum)
+ * v0.14.1, Sun, 22 Mar 2026 05:52:05 GMT (https://github.com/mar10/wunderbaum)
  */
 // const START_MARKER = "\uFFF7";
 class EditExtension extends WunderbaumExtension {
@@ -5866,7 +6054,7 @@ class EditExtension extends WunderbaumExtension {
             newValue = newValue.trim();
         }
         if (!node) {
-            this.tree.logDebug("stopEditTitle: not in edit mode.");
+            // this.tree.logDebug("stopEditTitle: not in edit mode.");
             return;
         }
         node.logDebug(`stopEditTitle(${apply})`, options, focusElem, newValue);
@@ -5966,8 +6154,8 @@ class EditExtension extends WunderbaumExtension {
  * https://github.com/mar10/wunderbaum
  *
  * Released under the MIT license.
- * @version v0.13.0
- * @date Sat, 08 Mar 2025 14:16:31 GMT
+ * @version v0.14.1
+ * @date Sun, 22 Mar 2026 05:52:05 GMT
  */
 // import "./wunderbaum.scss";
 class WbSystemRoot extends WunderbaumNode {
@@ -6016,17 +6204,17 @@ class Wunderbaum {
         this._disableUpdateIgnoreCount = 0;
         this._activeNode = null;
         this._focusNode = null;
+        this._initialSource = null;
         /** Shared properties, referenced by `node.type`. */
         this.types = {};
         /** List of column definitions. */
-        this.columns = []; // any[] = [];
+        this.columns = [];
         this._columnsById = {};
         // Modification Status
         this.pendingChangeTypes = new Set();
         /** Expose some useful methods of the util.ts module as `tree._util`. */
         this._util = util;
         // --- SELECT ---
-        // /** @internal */
         // public selectRangeAnchor: WunderbaumNode | null = null;
         // --- BREADCRUMB ---
         /** Filter options (used as defaults for calls to {@link Wunderbaum.filterNodes} ) */
@@ -6045,37 +6233,44 @@ class Wunderbaum {
         this.lastQuicksearchTerm = "";
         // --- EDIT ---
         this.lastClickTime = 0;
-        const opts = (this.options = extend({
-            id: null,
-            source: null, // URL for GET/PUT, Ajax options, or callback
-            element: null, // <div class="wunderbaum">
+        // Set default options and merge with user options
+        const initOptions = Object.assign({
+            id: undefined,
+            source: [], // URL for GET/PUT, Ajax options, or callback
+            element: unsafeCast(null),
             debugLevel: DEFAULT_DEBUGLEVEL, // 0:quiet, 1:errors, 2:warnings, 3:info, 4:verbose
             header: null, // Show/hide header (pass bool or string)
-            // headerHeightPx: ROW_HEIGHT,
             rowHeightPx: DEFAULT_ROW_HEIGHT,
             iconMap: "bootstrap",
-            columns: null,
-            types: null,
-            // escapeTitles: true,
+            columns: [], //util.unsafeCast<ColumnDefinitionList>(null),
+            types: {},
             enabled: true,
             fixedCol: false,
             showSpinner: false,
             checkbox: false,
             minExpandLevel: 0,
             emptyChildListExpandable: false,
-            // updateThrottleWait: 200,
             skeleton: false,
+            autoCollapse: false,
+            adjustHeight: true,
             connectTopBreadcrumb: null,
+            columnsFilterable: false,
+            columnsMenu: false,
+            columnsResizable: false,
+            columnsSortable: false,
             selectMode: "multi", // SelectModeType
+            scrollIntoViewOnExpandClick: true,
+            // --- Extensions (actually set by exensions on init)
+            dnd: unsafeCast(null),
+            edit: unsafeCast(null),
+            filter: unsafeCast(null),
             // --- KeyNav ---
-            navigationModeOption: null, // NavModeEnum,
+            navigationModeOption: unsafeCast(null),
             quicksearch: true,
             // --- Events ---
-            iconBadge: null,
-            change: null,
-            // enhanceTitle: null,
-            error: null,
-            receive: null,
+            // iconBadge: null,
+            // change: null,
+            // ...
             // --- Strings ---
             strings: {
                 loadError: "Error",
@@ -6086,7 +6281,9 @@ class Wunderbaum {
                 noMatch: "No results",
                 matchIndex: "${match} of ${matches}",
             },
-        }, options));
+        }, options);
+        const opts = initOptions;
+        this.options = opts;
         const readyDeferred = new Deferred();
         this.ready = readyDeferred.promise();
         let readyOk = false;
@@ -6113,7 +6310,8 @@ class Wunderbaum {
                 this._callEvent("init", { error: err });
             }
         });
-        this.id = opts.id || "wb_" + ++Wunderbaum.sequence;
+        this.id = initOptions.id || "wb_" + ++Wunderbaum.sequence;
+        delete initOptions.id;
         this.root = new WbSystemRoot(this);
         this._registerExtension(new KeynavExtension(this));
         this._registerExtension(new EditExtension(this));
@@ -6123,19 +6321,20 @@ class Wunderbaum {
         this._registerExtension(new LoggerExtension(this));
         this._updateViewportThrottled = adaptiveThrottle(this._updateViewportImmediately.bind(this), {});
         // --- Evaluate options
-        this.columns = opts.columns;
-        delete opts.columns;
+        this.columns = initOptions.columns || [];
+        delete initOptions.columns;
         if (!this.columns || !this.columns.length) {
             const title = typeof opts.header === "string" ? opts.header : this.id;
             this.columns = [{ id: "*", title: title, width: "*" }];
         }
-        if (opts.types) {
-            this.setTypes(opts.types, true);
+        if (initOptions.types) {
+            this.setTypes(initOptions.types, true);
         }
-        delete opts.types;
+        delete initOptions.types;
         // --- Create Markup
-        this.element = elemFromSelector(opts.element);
-        assert(!!this.element, `Invalid 'element' option: ${opts.element}`);
+        this.element = elemFromSelector(initOptions.element);
+        assert(!!this.element, `Invalid 'element' option: ${initOptions.element}`);
+        delete initOptions.element;
         this.element.classList.add("wunderbaum");
         if (!this.element.getAttribute("tabindex")) {
             this.element.tabIndex = 0;
@@ -6211,11 +6410,11 @@ class Wunderbaum {
             }
         });
         // --- Load initial data
-        if (opts.source) {
+        if (initOptions.source) {
             if (opts.showSpinner) {
                 this.nodeListElement.innerHTML = `<progress class='spinner'>${opts.strings.loading}</progress>`;
             }
-            this.load(opts.source)
+            this.load(initOptions.source)
                 .then(() => {
                 // The source may have defined columns, so we may adjust the nav mode
                 if (opts.navigationModeOption == null) {
@@ -6248,15 +6447,18 @@ class Wunderbaum {
         // has a wrong value at start???
         this.update(ChangeType.any);
         // --- Bind listeners
-        this.element.addEventListener("scroll", (e) => {
-            // this.log(`scroll, scrollTop:${e.target.scrollTop}`, e);
-            this.update(ChangeType.scroll);
-        });
+        this._registerEventHandlers();
         this.resizeObserver = new ResizeObserver((entries) => {
             // this.log("ResizeObserver: Size changed", entries);
             this.update(ChangeType.resize);
         });
         this.resizeObserver.observe(this.element);
+    }
+    _registerEventHandlers() {
+        this.element.addEventListener("scroll", (e) => {
+            // this.log(`scroll, scrollTop:${e.target.scrollTop}`, e);
+            this.update(ChangeType.scroll);
+        });
         onEvent(this.element, "click", ".wb-button,.wb-col-icon", (e) => {
             var _a, _b;
             const info = Wunderbaum.getEventInfo(e);
@@ -6272,9 +6474,6 @@ class Wunderbaum {
             const node = info.node;
             const mouseEvent = e;
             // this.log("click", info);
-            // if (this._selectRange(info) === false) {
-            //   return;
-            // }
             if (this._callEvent("click", { event: e, node: node, info: info }) === false) {
                 this.lastClickTime = Date.now();
                 return false;
@@ -6293,20 +6492,22 @@ class Wunderbaum {
                     (!slowClickDelay || Date.now() - this.lastClickTime < slowClickDelay)) {
                     node.startEditTitle();
                 }
-                if (info.colIdx >= 0) {
-                    node.setActive(true, { colIdx: info.colIdx, event: e });
-                }
-                else {
-                    node.setActive(true, { event: e });
-                }
                 if (info.region === NodeRegion.expander) {
                     node.setExpanded(!node.isExpanded(), {
-                        scrollIntoView: options.scrollIntoViewOnExpandClick !== false,
+                        scrollIntoView: this.options.scrollIntoViewOnExpandClick !== false,
                     });
                 }
                 else if (info.region === NodeRegion.checkbox) {
                     node.toggleSelected();
                 }
+                else {
+                    if (info.colIdx >= 0) {
+                        node.setActive(true, { colIdx: info.colIdx, event: e });
+                    }
+                    else {
+                        node.setActive(true, { event: e });
+                    }
+                }
             }
             this.lastClickTime = Date.now();
         });
@@ -6342,7 +6543,7 @@ class Wunderbaum {
             const targetNode = Wunderbaum.getNode(e);
             this._callEvent("focus", { flag: flag, event: e });
             if (flag && this.isRowNav() && !this.isEditingTitle()) {
-                if (opts.navigationModeOption === NavModeEnum.row) {
+                if (this.options.navigationModeOption === NavModeEnum.row) {
                     targetNode === null || targetNode === void 0 ? void 0 : targetNode.setActive();
                 }
                 else {
@@ -6409,11 +6610,12 @@ class Wunderbaum {
     }
     /**
      * Return the icon-function -> icon-definition mapping.
+     * @deprecated Use {@link Wunderbaum.iconMaps}
      */
     get iconMap() {
         const map = this.options.iconMap;
         if (typeof map === "string") {
-            return iconMaps[map];
+            return defaultIconMaps[map];
         }
         return map;
     }
@@ -6466,7 +6668,38 @@ class Wunderbaum {
             ext.init();
         }
     }
-    /** Add node to tree's bookkeeping data structures. */
+    /**
+     * Calculate a *stable*, unique key for a node from its refKey (or title).
+     * We also add information from the parent, because a refKey may occur multiple
+     * times in a tree (but not as child of the same parent).
+     * @internal
+     */
+    _calculateKey(data, parent) {
+        if (data.key) {
+            // Always use an explicitly passed key
+            return data.key;
+        }
+        // Auto-keys are optional, use a monotonic counter by default:
+        if (!this.options.autoKeys) {
+            return "" + ++WunderbaumNode.sequence;
+        }
+        // Add the parent's key to the hash. Assuming this was generated by the
+        // same algorithm, this should incorporate the whole path:
+        const s = (parent ? parent.key : "") + (data.refKey || data.title);
+        // 32-bit has a high probability of collisions, so we pump up to 64-bit
+        // https://security.stackexchange.com/q/209882/207588
+        const h1 = murmurHash3(s, true);
+        let key = "id_" + h1 + murmurHash3(h1 + s, true);
+        // Check for collisions
+        // (Most likely if the same title occurs multiple in the same parent).
+        const existingNode = this.keyMap.get(key);
+        if (existingNode) {
+            key += "." + ++Wunderbaum.sequence;
+            this.logWarn(`Node with existing key: '${existingNode}', using ${key}.`, data);
+        }
+        return key;
+    }
+    /** Add node to tree's bookkeeping data structures. @internal */
     _registerNode(node) {
         const key = node.key;
         assert(key != null, `Missing key: '${node}'.`);
@@ -6483,7 +6716,7 @@ class Wunderbaum {
             }
         }
     }
-    /** Remove node from tree's bookkeeping data structures. */
+    /** Remove node from tree's bookkeeping data structures. @internal  */
     _unregisterNode(node) {
         // Remove refKey reference from map (if any)
         const rk = node.refKey;
@@ -6602,6 +6835,16 @@ class Wunderbaum {
         bottomIdx = Math.min(bottomIdx, this.count(true) - 1);
         return this._getNodeByRowIdx(bottomIdx);
     }
+    /** Return preceding visible node in the viewport. */
+    _getPrevNodeInView(node, ofs = 1) {
+        this.visitRows((n) => {
+            node = n;
+            if (ofs-- <= 0) {
+                return false;
+            }
+        }, { reverse: true, start: node || this.getActiveNode() });
+        return node;
+    }
     /** Return following visible node in the viewport. */
     _getNextNodeInView(node, options) {
         let ofs = (options === null || options === void 0 ? void 0 : options.ofs) || 1;
@@ -6853,22 +7096,39 @@ class Wunderbaum {
     /** Run code, but defer rendering of viewport until done.
      *
      * ```js
-     * tree.runWithDeferredUpdate(() => {
-     *   return someFuncThatWouldUpdateManyNodes();
+     * const res = tree.runWithDeferredUpdate(() => {
+     *   return someFunctionThatWouldUpdateManyNodes();
      * });
      * ```
      */
-    runWithDeferredUpdate(func, hint = null) {
+    runWithDeferredUpdate(func) {
         try {
             this.enableUpdate(false);
             const res = func();
-            assert(!(res instanceof Promise), `Promise return not allowed: ${res}`);
+            assert(!(res instanceof Promise), `Promise return not allowed (see 'runWithDeferredUpdateAsync()'): ${res}`);
             return res;
         }
         finally {
             this.enableUpdate(true);
         }
     }
+    /** Run code, but defer rendering of viewport until done.
+     *
+     * ```js
+     * const res = await tree.runWithDeferredUpdate(async () => {
+     *   return someAsyncFunctionThatWouldUpdateManyNodes();
+     * });
+     * ```
+     */
+    async runWithDeferredUpdateAsync(func) {
+        try {
+            this.enableUpdate(false);
+            return await func();
+        }
+        finally {
+            this.enableUpdate(true);
+        }
+    }
     /** Recursively expand all expandable nodes (triggers lazy load if needed). */
     async expandAll(flag = true, options) {
         await this.root.expandAll(flag, options);
@@ -6888,6 +7148,17 @@ class Wunderbaum {
     getSelectedNodes(stopOnParents = false) {
         return this.root.getSelectedNodes(stopOnParents);
     }
+    /**
+     * Return an array of refKey values.
+     *
+     * RefKeys are unique identifiers for a node data, and are used to identify
+     * clones.
+     * If more than one node has the same refKey, it is only returned once.
+     * @param selected if true, only return refKeys of selected nodes.
+     */
+    getRefKeys(selected = false) {
+        return this.root.getRefKeys(selected);
+    }
     /*
      * Return an array of selected nodes.
      */
@@ -7169,6 +7440,18 @@ class Wunderbaum {
     format(name_cb, connectors) {
         return this.root.format(name_cb, connectors);
     }
+    /**
+     * Always returns null (so a tree instance behaves as `tree.root`).
+     */
+    get parent() {
+        return null;
+    }
+    /**
+     * Return a list of top-level nodes.
+     */
+    get children() {
+        return this.root.children || [];
+    }
     /**
      * Return the active cell (`span.wb-col`) of the currently active node or null.
      */
@@ -7287,7 +7570,7 @@ class Wunderbaum {
     }
     /** Return true if any node title or grid cell is currently beeing edited.
      *
-     * See also {@link Wunderbaum.isEditingTitle}.
+     * See also {@link isEditingTitle}.
      */
     isEditing() {
         const focusElem = this.nodeListElement.querySelector("input:focus,select:focus");
@@ -7295,7 +7578,7 @@ class Wunderbaum {
     }
     /** Return true if any node is currently in edit-title mode.
      *
-     * See also {@link WunderbaumNode.isEditingTitle} and {@link Wunderbaum.isEditing}.
+     * See also {@link WunderbaumNode.isEditingTitle} and {@link isEditing}.
      */
     isEditingTitle() {
         return this._callMethod("edit.isEditingTitle");
@@ -7315,7 +7598,7 @@ class Wunderbaum {
         return res;
     }
     /** Write to `console.log` with tree name as prefix if opts.debugLevel >= 4.
-     * @see {@link Wunderbaum.logDebug}
+     * @see {@link logDebug}
      */
     log(...args) {
         if (this.options.debugLevel >= 4) {
@@ -7324,7 +7607,7 @@ class Wunderbaum {
     }
     /** Write to `console.debug`  with tree name as prefix if opts.debugLevel >= 4.
      * and browser console level includes debug/verbose messages.
-     * @see {@link Wunderbaum.log}
+     * @see {@link log}
      */
     logDebug(...args) {
         if (this.options.debugLevel >= 4) {
@@ -7362,6 +7645,19 @@ class Wunderbaum {
             console.warn(this.toString(), ...args); // eslint-disable-line no-console
         }
     }
+    /** Emit a warning for deprecated methods. @internal */
+    logDeprecate(method, options) {
+        if (this.options.debugLevel >= 2) {
+            let msg = `${this}: ${method} is deprecated`;
+            if (options === null || options === void 0 ? void 0 : options.since) {
+                msg += ` since ${options.since}`;
+            }
+            if (options === null || options === void 0 ? void 0 : options.hint) {
+                msg += ` (${options.since})`;
+            }
+            console.warn(msg + "."); // eslint-disable-line no-console
+        }
+    }
     /** Reset column widths to default. @since 0.10.0 */
     resetColumns() {
         this.columns.forEach((col) => {
@@ -7530,46 +7826,64 @@ class Wunderbaum {
         this._focusNode = node;
     }
     /** Return the current selection/expansion/activation status. @experimental */
-    getState(options) {
+    getState(options = {}) {
         var _a, _b;
-        let expandedKeys = undefined;
-        if (options.expandedKeys !== false) {
-            expandedKeys = [];
+        const { activeKey = true, expandedKeys = false, selectedKeys = false, } = options;
+        const expandSet = new Set();
+        if (expandedKeys) {
             for (const node of this) {
-                if (node.expanded) {
-                    expandedKeys.push(node.key);
+                if (node.isExpanded() && node.hasChildren()) {
+                    expandSet.add(node.key);
                 }
             }
         }
+        // Parents of active node are always expanded
+        if (activeKey && this.activeNode) {
+            this.activeNode.visitParents((n) => {
+                if (n.parent) {
+                    expandSet.add(n.key);
+                }
+            }, false);
+        }
         const state = {
+            expandedKeys: expandSet.size ? Array.from(expandSet) : undefined,
             activeKey: (_b = (_a = this.activeNode) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : null,
             activeColIdx: this.activeColIdx,
-            selectedKeys: options.selectedKeys === false
-                ? undefined
-                : this.getSelectedNodes().flatMap((n) => n.key),
-            expandedKeys: expandedKeys,
+            selectedKeys: selectedKeys
+                ? this.getSelectedNodes().flatMap((n) => n.key)
+                : undefined,
         };
         return state;
     }
     /** Apply selection/expansion/activation status. @experimental */
-    setState(state, options) {
-        this.runWithDeferredUpdate(() => {
+    async setState(state, options = {}) {
+        const { expandLazy = true } = options;
+        return this.runWithDeferredUpdateAsync(async () => {
             var _a, _b;
-            if (state.selectedKeys) {
-                this.selectAll(false);
-                for (const key of state.selectedKeys) {
-                    (_a = this.findKey(key)) === null || _a === void 0 ? void 0 : _a.setSelected(true);
+            if (state.expandedKeys && state.expandedKeys.length) {
+                if (expandLazy) {
+                    // Expand all keys recursively, even if they are not in the tree yet
+                    await this._loadLazyNodes(state.expandedKeys, {
+                        expand: true,
+                        noEvents: true,
+                    });
                 }
-            }
-            if (state.expandedKeys) {
-                for (const key of state.expandedKeys) {
-                    (_b = this.findKey(key)) === null || _b === void 0 ? void 0 : _b.setExpanded(true);
+                else {
+                    for (const key of state.expandedKeys) {
+                        (_a = this.findKey(key)) === null || _a === void 0 ? void 0 : _a.setExpanded(true);
+                    }
                 }
             }
             if (state.activeKey) {
                 this.setActiveNode(state.activeKey);
             }
-            if (state.activeColIdx != null) {
+            if (state.selectedKeys) {
+                this.selectAll(false);
+                for (const key of state.selectedKeys) {
+                    (_b = this.findKey(key)) === null || _b === void 0 ? void 0 : _b.setSelected(true);
+                }
+            }
+            if (this.isCellNav() && state.activeColIdx != null) {
                 this.setColumn(state.activeColIdx);
             }
         });
@@ -7730,18 +8044,33 @@ class Wunderbaum {
      * @param {function} cmp custom compare function(a, b) that returns -1, 0, or 1
      *    (defaults to sorting by title).
      * @param {boolean} deep pass true to sort all descendant nodes recursively
+     * @deprecated use {@link sort}
      */
     sortChildren(cmp = nodeTitleSorter, deep = false) {
-        this.root.sortChildren(cmp, deep);
+        this.logDeprecate("sortChildren()", { since: "0.14.0" });
+        return this.sort({
+            cmp: cmp ? cmp : undefined,
+            deep: deep,
+            propName: "title",
+        });
     }
     /**
      * Convenience method to implement column sorting.
      * @see {@link WunderbaumNode.sortByProperty}.
      * @since 0.11.0
+     * @deprecated use {@link sort}
      */
     sortByProperty(options) {
+        this.logDeprecate("sortByProperty()", { since: "0.14.0" });
         this.root.sortByProperty(options);
     }
+    /**
+     * Sort nodes list by title or custom criteria.
+     * @since 0.14.0
+     */
+    sort(options) {
+        this.root.sort(options);
+    }
     /** Convert tree to an array of plain objects.
      *
      * @param callback is called for every node, in order to allow
@@ -7993,12 +8322,10 @@ class Wunderbaum {
             iconElem = document.createElement("i");
             iconElem.className = "wb-icon";
         }
-        else if (icon.indexOf("<") >= 0) {
-            // HTML
+        else if (TEST_HTML.test(icon)) {
             iconElem = elemFromHtml(icon);
         }
-        else if (TEST_IMG.test(icon)) {
-            // Image URL
+        else if (TEST_FILE_PATH.test(icon)) {
             iconElem = elemFromHtml(`<i class="wb-icon" style="background-image: url('${icon}');">`);
         }
         else {
@@ -8236,7 +8563,8 @@ class Wunderbaum {
     }
     /**
      * Call `callback(node)` for all nodes in hierarchical order (depth-first, pre-order).
-     * @see {@link IterableIterator<WunderbaumNode>}, {@link WunderbaumNode.visit}.
+     * @see `wb_node.WunderbaumNode.IterableIterator<WunderbaumNode>`
+     * @see {@link WunderbaumNode.visit}.
      *
      * @param {function} callback the callback function.
      *     Return false to stop iteration, return "skip" to skip this node and
@@ -8379,11 +8707,71 @@ class Wunderbaum {
      *
      * Previous data is cleared. Note that also column- and type defintions may
      * be passed with the `source` object.
+     * @see {@link Wunderbaum.reload} for a shortcut to reload the last ajax request
+     * and restore the previous state.
      */
-    load(source) {
+    async load(source) {
         this.clear();
+        this._initialSource = source;
         return this.root.load(source);
     }
+    /** Reload the tree and optionally restore state.
+     * Source defaults to last ajax url if any.
+     * Restoring the active node requires stable keys
+     * @see {@link WunderbaumOptions.autoKeys}
+     * @see {@link Wunderbaum.load}
+     * @experimental
+     */
+    async reload(options = {}) {
+        const { source = this._initialSource, reactivate = true } = options;
+        if (!source) {
+            this.logWarn("No previous ajax source to reload.");
+            return;
+        }
+        if (!reactivate) {
+            return this.load(source);
+        }
+        const state = this.getState();
+        await this.load(source);
+        return this.setState(state);
+    }
+    /**
+     * Make sure that all nodes in the given keyList are accessible.
+     * This may include loading lazy parent nodes.
+     * Recursively load (and optionally expand) all requested node paths.
+     */
+    async _loadLazyNodes(keyList, options = {}) {
+        const { expand = true } = options;
+        const keySet = new Set(keyList);
+        // Make sure that all parent nodes are loaded (and expand if requested)
+        while (keySet.size > 0) {
+            const pendingNodes = [];
+            const curSet = new Set(keySet);
+            for (const key of curSet) {
+                const node = this.findKey(key);
+                if (!node) {
+                    continue; // key not yet found (need to load lazy parent?)
+                }
+                keySet.delete(key);
+                if (expand) {
+                    pendingNodes.push(node.setExpanded(true));
+                }
+                else if (node.isUnloaded()) {
+                    pendingNodes.push(node.loadLazy());
+                }
+                if (node._rowElem) {
+                    node._render(); // show spinner even is update is suppressed
+                }
+            }
+            if (pendingNodes.length === 0) {
+                // will not load any more nodes, so if if there are still keys
+                // left in the set, we will never find them
+                this.logWarn(`Could not expand ${keySet.size} nodes:`, keySet);
+                break;
+            }
+            await Promise.allSettled(pendingNodes);
+        }
+    }
     /**
      * Disable render requests during operations that would trigger many updates.
      *
@@ -8481,8 +8869,20 @@ class Wunderbaum {
 }
 Wunderbaum.sequence = 0;
 /** Wunderbaum release version number "MAJOR.MINOR.PATCH". */
-Wunderbaum.version = "v0.13.0"; // Set to semver by 'grunt release'
+Wunderbaum.version = "v0.14.1"; // Set to semver by 'grunt release'
 /** Expose some useful methods of the util.ts module as `Wunderbaum.util`. */
 Wunderbaum.util = util;
+/** A map of default iconMaps.
+ * May be used as default, when passing partial icon definition maps:
+ * ```js
+ * const tree = new mar10.Wunderbaum({
+ *   ...
+ *   iconMap: Object.assign(Wunderbaum.iconMaps.bootstrap, {
+ *     folder: "bi bi-archive",
+ *   }),
+ * });
+ * ```
+ */
+Wunderbaum.iconMaps = defaultIconMaps;
 
 export { Wunderbaum };