@wavemaker-ai/react-runtime 1.0.0-rc.312 → 1.0.0-rc.317

package/components/basic/tree/props.d.ts

@@ -29,6 +29,17 @@ export interface TreeItem {
     tId?: string;
     isParent?: boolean;
 }
+/** Persisted tree widget state shape (URL / localStorage / sessionStorage via wm_state). */
+export type TreeUrlState = {
+    /** Node ids that are expanded (nested shells open). Ancestors need not be listed; they are implied. */
+    expanded?: string[];
+    /** Last selected node id (optional). */
+    selected?: string;
+    /** @deprecated Legacy shape — migrated on read */
+    id?: string;
+    open?: boolean;
+    parentNode?: string[];
+};
 /**
  * Base props specific to the WmTree component.
  */
@@ -90,6 +101,8 @@ export interface TreeProps {
      **template**: partial name for custom node rendering .
      */
     template?: string;
+    /** Persist expansion/selection via `URL`, `localStorage`, or `sessionStorage` (wm_state). */
+    statehandler?: string;
 }
 /**
  * Combined props for the WmTree component, including base WaveMaker props.
@@ -113,7 +126,11 @@ export interface TreeNodeComponentProps {
     /** Partial name from {@link TreeProps.template}; replaces default row with partial UI when set */
     template?: string;
     /** Page / fragment listener for partial container + widget registry */
-    listener?: Record<string, unknown>;
+    listener?: Record<string, unknown> | undefined;
+    /** Normalized expanded ids from URL (overlay until tree state hydrates) */
+    urlExpansionOverlay?: Set<string> | undefined;
+    /** Selected node id from URL persistence */
+    urlSelectedId?: string | undefined;
 }
 export type TreePartialNodeApi = {
     select: () => void;

package/components/basic/tree/props.js

@@ -1,5 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});

package/components/basic/tree/utils.d.ts

@@ -1,4 +1,5 @@
-import { TreeNodeData, TreeItem, TreePartialNodeApi } from "./props";
+import { type StorageType } from "@wavemaker-ai/react-runtime/utils/state-persistance";
+import { TreeNodeData, TreeItem, TreePartialNodeApi, TreeUrlState } from "./props";
 /** Whether the dataset row (`node.data`) is disabled via its `disabled` property. */
 export declare const isTreeNodeDisabled: (data: TreeNodeData | undefined | null) => boolean;
 export declare const getNestedPropertyLocal: (obj: any, path: string) => any;
@@ -17,6 +18,20 @@ export declare const findNodeById: (nodes: TreeItem[], id: string) => TreeItem |
  * Used so partial templates can expand/collapse by id even when the passed-in `TreeItem`
  */
 export declare const toggleExpansionInTree: (nodes: TreeItem[], nodeId: string) => TreeItem[];
+/** Migrate legacy `{ id, open, parentNode }` URL payloads to an `expanded` id list. */
+export declare const migrateLegacyTreeUrlState: (raw: TreeUrlState | null | undefined) => string[];
+/**
+ * Ensures all ancestors of every expanded id are included so nested paths reopen after refresh.
+ */
+export declare const normalizeExpandedIds: (tree: TreeItem[], expandedIds: Iterable<string>) => Set<string>;
+/**
+ * Node ids that are expanded **in the visible tree** (parent chain must be open / pre-open).
+ * Descendants of a collapsed branch are omitted even if `open` flags were left true internally.
+ */
+export declare const collectExpandedNodeIdsForUrl: (nodes: TreeItem[]) => string[];
+export declare const saveTreeState: (name: string, storage: StorageType, stateToSave: Partial<TreeUrlState> | null) => void;
+export declare const getTreeState: (name: string, storage: StorageType) => TreeUrlState | null;
+export declare const clearTreeState: (name: string, storage: StorageType) => void;
 /**
  * Dataset row fields for `pageParams.item` (no methods — those are merged in the hook as {@link TreePartialNodeApi}).
  */

package/components/basic/tree/utils.js

@@ -1,272 +1,327 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.toggleExpansionInTree = exports.processNode = exports.isTreeNodeDisabled = exports.getTreePartialRowPayload = exports.getNestedPropertyLocal = exports.generateUniqueNodeId = exports.findNodeById = exports.computeTreeNodeDepthFromRoot = exports.buildTreePathFromRoot = exports.buildTreePartialSnapshot = exports.assembleTreePartialItem = void 0;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _isArray = _interopRequireDefault(require("lodash-es/isArray"));
-var _cloneDeep = _interopRequireDefault(require("lodash-es/cloneDeep"));
-var _get = _interopRequireDefault(require("lodash-es/get"));
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-/** Whether the dataset row (`node.data`) is disabled via its `disabled` property. */
-var isTreeNodeDisabled = exports.isTreeNodeDisabled = function isTreeNodeDisabled(data) {
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import isArray from "lodash-es/isArray";
+import cloneDeep from "lodash-es/cloneDeep";
+import get from "lodash-es/get";
+import {
+  clearWidgetState,
+  getWidgetState,
+  setWidgetState
+} from "../../../utils/state-persistance";
+const isTreeNodeDisabled = (data) => {
   if (!data) return false;
-  var disabled_node = data.disabled;
+  const disabled_node = data.disabled;
   if (disabled_node === false || disabled_node === "false") {
     return false;
   }
   return Boolean(disabled_node);
 };
-
-// Helper function to get nested property (local version for processNode)
-var getNestedPropertyLocal = exports.getNestedPropertyLocal = function getNestedPropertyLocal(obj, path) {
-  if (!path || !obj) return undefined;
+const getNestedPropertyLocal = (obj, path) => {
+  if (!path || !obj) return void 0;
   try {
-    var normalizedPath = path.replace(/\[(\d+)\]/g, ".$1").replace(/^\./, "");
-    return (0, _get["default"])(obj, normalizedPath);
+    const normalizedPath = path.replace(/\[(\d+)\]/g, ".$1").replace(/^\./, "");
+    return get(obj, normalizedPath);
   } catch (error) {
-    return undefined;
+    return void 0;
   }
 };
-
-// Function to generate unique nodeId
-var generateUniqueNodeId = exports.generateUniqueNodeId = function generateUniqueNodeId(baseId, usedNodeIds) {
-  var uniqueId = baseId;
-  var counter = 1;
+const generateUniqueNodeId = (baseId, usedNodeIds) => {
+  let uniqueId = baseId;
+  let counter = 1;
   while (usedNodeIds.has(uniqueId)) {
-    uniqueId = "".concat(baseId, "_").concat(counter);
+    uniqueId = `${baseId}_${counter}`;
     counter++;
   }
   usedNodeIds.add(uniqueId);
   return uniqueId;
 };
-
-// Process a single node and its children with depth tracking
-var _processNode = exports.processNode = function processNode(item, depth, parent, rootDataset, nodeIndex, treeName, options) {
-  var levels = options.levels,
-    nodelabel = options.nodelabel,
-    nodeicon = options.nodeicon,
-    nodechildren = options.nodechildren,
-    nodeid = options.nodeid,
-    generateUniqueNodeId = options.generateUniqueNodeId;
-
-  // Helper functions for property resolution
-  var getLabelValue = function getLabelValue() {
-    var _ref, _ref2, _ref3, _item$nodelabel;
+const processNode = (item, depth, parent, rootDataset, nodeIndex, treeName, options) => {
+  const { levels, nodelabel, nodeicon, nodechildren, nodeid, generateUniqueNodeId: generateUniqueNodeId2 } = options;
+  const getLabelValue = () => {
+    var _a, _b, _c, _d;
     if (nodelabel && (nodelabel.includes("[") || nodelabel.includes("."))) {
-      // Try to get the property from the current item only (like Angular's getEvaluatedData)
-      var currentItemValue = getNestedPropertyLocal(item, nodelabel);
-      if (currentItemValue !== undefined) {
+      const currentItemValue = getNestedPropertyLocal(item, nodelabel);
+      if (currentItemValue !== void 0) {
         return currentItemValue;
       }
-      // If not found on current item, fall back to default values (don't do global search)
     }
-    return (_ref = (_ref2 = (_ref3 = (_item$nodelabel = item[nodelabel]) !== null && _item$nodelabel !== void 0 ? _item$nodelabel : item.label) !== null && _ref3 !== void 0 ? _ref3 : item.name) !== null && _ref2 !== void 0 ? _ref2 : String(item)) !== null && _ref !== void 0 ? _ref : nodelabel;
+    return (_d = (_c = (_b = (_a = item[nodelabel]) != null ? _a : item.label) != null ? _b : item.name) != null ? _c : String(item)) != null ? _d : nodelabel;
   };
-  var getIconValue = function getIconValue() {
-    var _ref4, _item$nodeicon;
+  const getIconValue = () => {
+    var _a, _b;
     if (nodeicon && (nodeicon.includes("[") || nodeicon.includes("."))) {
-      // Try to get the property from the current item only (like Angular's getEvaluatedData)
-      var currentItemValue = getNestedPropertyLocal(item, nodeicon);
-      if (currentItemValue !== undefined) {
+      const currentItemValue = getNestedPropertyLocal(item, nodeicon);
+      if (currentItemValue !== void 0) {
         return currentItemValue;
       }
-      // If not found on current item, fall back to default values (don't do global search)
     }
-    return (_ref4 = (_item$nodeicon = item[nodeicon]) !== null && _item$nodeicon !== void 0 ? _item$nodeicon : item.icon) !== null && _ref4 !== void 0 ? _ref4 : nodeicon;
+    return (_b = (_a = item[nodeicon]) != null ? _a : item.icon) != null ? _b : nodeicon;
   };
-  var getNodeIdValue = function getNodeIdValue() {
+  const getNodeIdValue = () => {
+    var _a, _b;
     if (nodeid && (nodeid.includes("[") || nodeid.includes("."))) {
-      // Try to get the property from the current item only (like Angular's getEvaluatedData)
-      var currentItemValue = getNestedPropertyLocal(item, nodeid);
-      if (currentItemValue !== undefined) {
+      const currentItemValue = getNestedPropertyLocal(item, nodeid);
+      if (currentItemValue !== void 0) {
         return String(currentItemValue);
       }
-      // If not found on current item, return undefined (no fallback like Angular)
-      return undefined;
+      return void 0;
     }
-
-    // For direct properties, return the value or undefined (no fallback like Angular)
-    var directValue = item[nodeid];
-    if (directValue !== undefined) {
+    const directValue = item[nodeid];
+    if (directValue !== void 0) {
       return String(directValue);
     }
-
-    // If no nodeid specified or found, generate a fallback for React's internal use
     if (!nodeid) {
-      var _ref5, _item$nodeId;
-      var fallbackId = (_ref5 = (_item$nodeId = item.nodeId) !== null && _item$nodeId !== void 0 ? _item$nodeId : item.id) !== null && _ref5 !== void 0 ? _ref5 : "node_".concat(Date.now(), "_").concat(Math.random());
+      const fallbackId = (_b = (_a = item.nodeId) != null ? _a : item.id) != null ? _b : `node_${Date.now()}_${Math.random()}`;
       return String(fallbackId);
     }
-    return undefined;
+    return void 0;
   };
-  var getChildrenValue = function getChildrenValue() {
+  const getChildrenValue = () => {
     if (nodechildren && (nodechildren.includes("[") || nodechildren.includes("."))) {
-      // Try to get the property from the current item only (like Angular's getEvaluatedData)
-      var currentItemValue = getNestedPropertyLocal(item, nodechildren);
-      if (currentItemValue !== undefined) {
+      const currentItemValue = getNestedPropertyLocal(item, nodechildren);
+      if (currentItemValue !== void 0) {
         return currentItemValue;
       }
-      // If not found on current item, fall back to default values (don't do global search)
     }
-    // Use logical OR (||) like Angular to fall back to item.children only if the result is falsy
     return item[nodechildren] || item.children;
   };
-  var labelValue = getLabelValue();
-  var iconValue = getIconValue();
-  var nodeIdValue = getNodeIdValue();
-  var childrenData = getChildrenValue();
-
-  // Ensure we have a unique nodeId for React's internal use
-  // If nodeIdValue is undefined (like Angular), generate a fallback
-  var finalNodeId = nodeIdValue || generateUniqueNodeId("node_".concat(Date.now(), "_").concat(nodeIndex || 0));
-  var node = {
+  const labelValue = getLabelValue();
+  const iconValue = getIconValue();
+  const nodeIdValue = getNodeIdValue();
+  const childrenData = getChildrenValue();
+  const finalNodeId = nodeIdValue || generateUniqueNodeId2(`node_${Date.now()}_${nodeIndex || 0}`);
+  const node = {
     name: String(labelValue || ""),
     label: String(labelValue || ""),
     icon: iconValue,
     nodeId: String(finalNodeId),
-    data: (0, _cloneDeep["default"])(item),
+    data: cloneDeep(item),
     open: depth < levels,
     checked: item.checked || false,
-    parent: parent,
-    tId: treeName ? "".concat(treeName, "_").concat(finalNodeId) : "tree_node_".concat(finalNodeId),
-    isParent: (0, _isArray["default"])(childrenData) && childrenData.length > 0
+    parent,
+    tId: treeName ? `${treeName}_${finalNodeId}` : `tree_node_${finalNodeId}`,
+    isParent: isArray(childrenData) && childrenData.length > 0
   };
-  if ((0, _isArray["default"])(childrenData) && childrenData.length > 0) {
-    node.children = childrenData.map(function (child, index) {
-      return _processNode(child, depth + 1, node, rootDataset, index, treeName, options);
-    });
+  if (isArray(childrenData) && childrenData.length > 0) {
+    node.children = childrenData.map(
+      (child, index) => processNode(child, depth + 1, node, rootDataset, index, treeName, options)
+    );
   }
   return node;
 };
-var _findNodeById = exports.findNodeById = function findNodeById(nodes, id) {
-  var _iterator = _createForOfIteratorHelper(nodes),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _node$children;
-      var node = _step.value;
-      if (String(node.nodeId) === String(id)) return node;
-      if ((_node$children = node.children) !== null && _node$children !== void 0 && _node$children.length) {
-        var found = _findNodeById(node.children, id);
-        if (found) return found;
-      }
+const findNodeById = (nodes, id) => {
+  var _a;
+  for (const node of nodes) {
+    if (String(node.nodeId) === String(id)) return node;
+    if ((_a = node.children) == null ? void 0 : _a.length) {
+      const found = findNodeById(node.children, id);
+      if (found) return found;
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return null;
 };
-
-/**
- * Toggle `open` on the node matching `nodeId` using the **current** tree snapshot.
- * Used so partial templates can expand/collapse by id even when the passed-in `TreeItem`
- */
-var _toggleExpansionInTree = exports.toggleExpansionInTree = function toggleExpansionInTree(nodes, nodeId) {
-  return nodes.map(function (n) {
-    var _n$children;
+const toggleExpansionInTree = (nodes, nodeId) => {
+  return nodes.map((n) => {
+    var _a;
     if (n.nodeId === nodeId) {
-      return _objectSpread(_objectSpread({}, n), {}, {
-        open: !n.open
-      });
+      return __spreadProps(__spreadValues({}, n), { open: !n.open });
     }
-    if ((_n$children = n.children) !== null && _n$children !== void 0 && _n$children.length) {
-      return _objectSpread(_objectSpread({}, n), {}, {
-        children: _toggleExpansionInTree(n.children, nodeId)
-      });
+    if ((_a = n.children) == null ? void 0 : _a.length) {
+      return __spreadProps(__spreadValues({}, n), { children: toggleExpansionInTree(n.children, nodeId) });
     }
     return n;
   });
 };
-
-/**
- * Dataset row fields for `pageParams.item` (no methods — those are merged in the hook as {@link TreePartialNodeApi}).
- */
-var getTreePartialRowPayload = exports.getTreePartialRowPayload = function getTreePartialRowPayload(node) {
-  var _node$label;
-  var raw = node.data;
-  var row = raw && (0, _typeof2["default"])(raw) === "object" && !Array.isArray(raw) ? _objectSpread({}, raw) : {};
-  return _objectSpread(_objectSpread({}, row), {}, {
-    name: (_node$label = node.label) !== null && _node$label !== void 0 ? _node$label : node.name
+const migrateLegacyTreeUrlState = (raw) => {
+  if (!raw || typeof raw !== "object") return [];
+  if (Array.isArray(raw.expanded) && raw.expanded.length) {
+    return raw.expanded.map((id) => String(id));
+  }
+  const ids = /* @__PURE__ */ new Set();
+  if (Array.isArray(raw.parentNode)) {
+    for (const x of raw.parentNode) {
+      if (x != null && x !== "") ids.add(String(x));
+    }
+  }
+  if (raw.open && raw.id != null && raw.id !== "") {
+    ids.add(String(raw.id));
+  }
+  return [...ids];
+};
+const normalizeExpandedIds = (tree, expandedIds) => {
+  const set = /* @__PURE__ */ new Set();
+  for (const id of expandedIds) {
+    if (id == null || id === "") continue;
+    const node = findNodeById(tree, String(id));
+    if (!node) continue;
+    let current = node;
+    while (current) {
+      set.add(String(current.nodeId));
+      current = current.parent;
+    }
+  }
+  return set;
+};
+const collectExpandedNodeIdsForUrl = (nodes) => {
+  const out = [];
+  const walk = (list, branchOpen) => {
+    var _a;
+    for (const n of list) {
+      if (!branchOpen) continue;
+      if (n.open) {
+        out.push(n.nodeId);
+        if ((_a = n.children) == null ? void 0 : _a.length) {
+          walk(n.children, true);
+        }
+      }
+    }
+  };
+  walk(nodes, true);
+  return out;
+};
+const encodeNodeIdForUrl = (id) => {
+  try {
+    return btoa(unescape(encodeURIComponent(id))).replace(/=+$/, "");
+  } catch (e) {
+    return id;
+  }
+};
+const decodeNodeIdFromUrl = (token) => {
+  try {
+    return decodeURIComponent(escape(atob(token)));
+  } catch (e) {
+    return token;
+  }
+};
+const toTreeStatePayload = (storage, state) => {
+  var _a;
+  if (storage !== "URL") return state;
+  const out = {};
+  if ((_a = state.expanded) == null ? void 0 : _a.length) {
+    out.expanded = [...new Set(state.expanded.map(String))].map(encodeNodeIdForUrl);
+  }
+  if (state.selected) out.selected = encodeNodeIdForUrl(String(state.selected));
+  return out;
+};
+const fromTreeStatePayload = (storage, raw) => {
+  var _a, _b;
+  if (raw == null || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const state = raw;
+  if (storage !== "URL") return state;
+  const out = {};
+  if ((_a = state.expanded) == null ? void 0 : _a.length) {
+    out.expanded = [...new Set(state.expanded.map((id) => decodeNodeIdFromUrl(String(id))))];
+  }
+  if (state.selected) out.selected = decodeNodeIdFromUrl(String(state.selected));
+  return ((_b = out.expanded) == null ? void 0 : _b.length) || out.selected ? out : null;
+};
+const saveTreeState = (name, storage, stateToSave) => {
+  const config = { name, type: "tree", storage };
+  if (stateToSave == null) {
+    clearWidgetState(config);
+    return;
+  }
+  if (storage === "URL") {
+    clearWidgetState(config);
+  }
+  setWidgetState(config, toTreeStatePayload(storage, stateToSave));
+};
+const getTreeState = (name, storage) => {
+  return fromTreeStatePayload(storage, getWidgetState({ name, type: "tree", storage }));
+};
+const clearTreeState = (name, storage) => {
+  clearWidgetState({ name, type: "tree", storage });
+};
+const getTreePartialRowPayload = (node) => {
+  var _a;
+  const raw = node.data;
+  const row = raw && typeof raw === "object" && !Array.isArray(raw) ? __spreadValues({}, raw) : {};
+  return __spreadProps(__spreadValues({}, row), {
+    name: (_a = node.label) != null ? _a : node.name
   });
 };
-
-/**
- * Depth of the node from the tree root (root depth = 0).
- */
-var computeTreeNodeDepthFromRoot = exports.computeTreeNodeDepthFromRoot = function computeTreeNodeDepthFromRoot(node) {
-  var depthFromRoot = 0;
-  var ancestor = node.parent;
+const computeTreeNodeDepthFromRoot = (node) => {
+  let depthFromRoot = 0;
+  let ancestor = node.parent;
   while (ancestor) {
     depthFromRoot += 1;
     ancestor = ancestor.parent;
   }
   return depthFromRoot;
 };
-
-/**
- * Slash-separated path from root to this node (`/a/b/c`).
- */
-var buildTreePathFromRoot = exports.buildTreePathFromRoot = function buildTreePathFromRoot(node) {
+const buildTreePathFromRoot = (node) => {
   if (!node) return "";
-  var segments = [];
-  var current = node;
+  const segments = [];
+  let current = node;
   while (current) {
     segments.unshift(current.name);
     current = current.parent;
   }
-  return "/".concat(segments.join("/"));
+  return `/${segments.join("/")}`;
 };
-
-/**
- * Plain zTree-shaped snapshot for `item._node`. Nested `children` are data-only; methods are merged in {@link useTreePartialNodeApi}.
- */
-var _buildTreePartialSnapshot = exports.buildTreePartialSnapshot = function buildTreePartialSnapshot(node, selectedTreeNodeId) {
-  var _node$parent, _node$parent$nodeId, _node$parent2, _node$tId, _node$name, _node$label2, _siblings$length;
-  var siblings = (_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.children;
-  var rawSiblingIndex = siblings !== null && siblings !== void 0 && siblings.length ? siblings.findIndex(function (child) {
-    return String(child.nodeId) === String(node.nodeId);
-  }) : 0;
-  var siblingIndex = rawSiblingIndex < 0 ? 0 : rawSiblingIndex;
-  var level = computeTreeNodeDepthFromRoot(node);
-  var hasChildren = !!(node.children && node.children.length > 0);
-  var selectedId = selectedTreeNodeId != null ? String(selectedTreeNodeId) : "";
+const buildTreePartialSnapshot = (node, selectedTreeNodeId) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const siblings = (_a = node.parent) == null ? void 0 : _a.children;
+  const rawSiblingIndex = (siblings == null ? void 0 : siblings.length) ? siblings.findIndex((child) => String(child.nodeId) === String(node.nodeId)) : 0;
+  const siblingIndex = rawSiblingIndex < 0 ? 0 : rawSiblingIndex;
+  const level = computeTreeNodeDepthFromRoot(node);
+  const hasChildren = !!(node.children && node.children.length > 0);
+  const selectedId = selectedTreeNodeId != null ? String(selectedTreeNodeId) : "";
   return {
     data: node.data,
     nodeId: node.nodeId,
-    parentId: (_node$parent$nodeId = (_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.nodeId) !== null && _node$parent$nodeId !== void 0 ? _node$parent$nodeId : null,
-    tId: (_node$tId = node.tId) !== null && _node$tId !== void 0 ? _node$tId : "",
-    name: (_node$name = node.name) !== null && _node$name !== void 0 ? _node$name : "",
-    label: (_node$label2 = node.label) !== null && _node$label2 !== void 0 ? _node$label2 : "",
-    level: level,
-    children: hasChildren ? node.children.map(function (child) {
-      return _buildTreePartialSnapshot(child, selectedTreeNodeId);
-    }) : [],
+    parentId: (_c = (_b = node.parent) == null ? void 0 : _b.nodeId) != null ? _c : null,
+    tId: (_d = node.tId) != null ? _d : "",
+    name: (_e = node.name) != null ? _e : "",
+    label: (_f = node.label) != null ? _f : "",
+    level,
+    children: hasChildren ? node.children.map((child) => buildTreePartialSnapshot(child, selectedTreeNodeId)) : [],
     isParent: hasChildren,
     isFirstNode: siblings ? siblingIndex === 0 : true,
-    isLastNode: siblings ? siblingIndex === ((_siblings$length = siblings === null || siblings === void 0 ? void 0 : siblings.length) !== null && _siblings$length !== void 0 ? _siblings$length : 1) - 1 : true,
+    isLastNode: siblings ? siblingIndex === ((_g = siblings == null ? void 0 : siblings.length) != null ? _g : 1) - 1 : true,
     open: !!node.open,
     checked: !!node.checked,
     checkedOld: !!node.checked,
     isSelected: selectedId !== "" && selectedId === String(node.nodeId)
   };
 };
-
-/**
- * Full `item` for wm-tree partials (`params: ['item']`).
- */
-var assembleTreePartialItem = exports.assembleTreePartialItem = function assembleTreePartialItem(node, partialNodeApi) {
-  return _objectSpread(_objectSpread({}, getTreePartialRowPayload(node)), {}, {
-    node: partialNodeApi,
-    _node: partialNodeApi
-  });
-};
+const assembleTreePartialItem = (node, partialNodeApi) => __spreadProps(__spreadValues({}, getTreePartialRowPayload(node)), {
+  node: partialNodeApi,
+  _node: partialNodeApi
+});
+export {
+  assembleTreePartialItem,
+  buildTreePartialSnapshot,
+  buildTreePathFromRoot,
+  clearTreeState,
+  collectExpandedNodeIdsForUrl,
+  computeTreeNodeDepthFromRoot,
+  findNodeById,
+  generateUniqueNodeId,
+  getNestedPropertyLocal,
+  getTreePartialRowPayload,
+  getTreeState,
+  isTreeNodeDisabled,
+  migrateLegacyTreeUrlState,
+  normalizeExpandedIds,
+  processNode,
+  saveTreeState,
+  toggleExpansionInTree
+};