@wavemaker-ai/react-runtime 1.0.0-rc.314 → 1.0.0-rc.319

package/components/basic/tree/Components/TreeNodeComponent.js

@@ -39,8 +39,12 @@ const TreeNodeComponent = React.memo(
     depth = 0,
     treeName,
     template,
-    listener
+    listener,
+    urlExpansionOverlay,
+    urlSelectedId
   }) => {
+    const isNodeOpen = node.open || !!(urlExpansionOverlay == null ? void 0 : urlExpansionOverlay.has(node.nodeId));
+    const isSelected = (selectedItem == null ? void 0 : selectedItem.nodeId) === node.nodeId || urlSelectedId === node.nodeId;
     const hasChildren = node.children && node.children.length > 0;
     const disabledClassName = useMemo(() => {
       return isTreeNodeDisabled(node.data) ? "wm-tree-node-disabled" : "";
@@ -79,7 +83,7 @@ const TreeNodeComponent = React.memo(
               "button",
               `level${depth}`,
               "switch",
-              depth === 0 ? node.open ? "roots_open" : "roots_close" : node.open ? "bottom_open" : "bottom_close",
+              depth === 0 ? isNodeOpen ? "roots_open" : "roots_close" : isNodeOpen ? "bottom_open" : "bottom_close",
               treeicons,
               "treenode_switch",
               disabledClassName
@@ -156,7 +160,7 @@ const TreeNodeComponent = React.memo(
             `level${depth}`,
             !template && "glyphicon",
             !template && (node.icon || "glyphicon-music"),
-            { curSelectedNode: (selectedItem == null ? void 0 : selectedItem.nodeId) === node.nodeId },
+            { curSelectedNode: isSelected },
             "treenode_a",
             disabledClassName
           ),
@@ -181,7 +185,7 @@ const TreeNodeComponent = React.memo(
     };
     const renderChildNodes = () => {
       if (!hasChildren) return null;
-      return /* @__PURE__ */ jsx(Collapse, { in: !!node.open, timeout: "auto", unmountOnExit: false, children: /* @__PURE__ */ jsx(
+      return /* @__PURE__ */ jsx(Collapse, { in: isNodeOpen, timeout: "auto", unmountOnExit: false, children: /* @__PURE__ */ jsx(
         Box,
         {
           component: "ul",
@@ -189,7 +193,7 @@ const TreeNodeComponent = React.memo(
             `level${depth}`,
             "line",
             "wm-tree-children-list",
-            node.open ? "wm-tree-children-open" : "wm-tree-children-closed"
+            isNodeOpen ? "wm-tree-children-open" : "wm-tree-children-closed"
           ),
           id: `${node.tId}_ul`,
           children: node.children && node.children.map((childNode) => /* @__PURE__ */ jsx(
@@ -207,7 +211,9 @@ const TreeNodeComponent = React.memo(
               depth: depth + 1,
               treeName,
               template,
-              listener
+              listener,
+              urlExpansionOverlay,
+              urlSelectedId
             },
             childNode.nodeId
           ))
@@ -219,10 +225,10 @@ const TreeNodeComponent = React.memo(
       __spreadProps(__spreadValues({
         component: "li",
         className: clsx(`level${depth}`, {
-          selected: (selectedItem == null ? void 0 : selectedItem.nodeId) === node.nodeId
+          selected: isSelected
         }),
         id: node.tId,
-        tabIndex: (selectedItem == null ? void 0 : selectedItem.nodeId) === node.nodeId ? 0 : -1
+        tabIndex: isSelected ? 0 : -1
       }, { treenode: "true" }), {
         children: [
           !template && renderExpandCollapseIcon(),

package/components/basic/tree/hooks/useTreePersistedState.d.ts

@@ -0,0 +1,3 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { TreeUrlState } from "../props";
+export declare function useTreePersistedState(name: string, statehandler: string | undefined): readonly [TreeUrlState | null, Dispatch<SetStateAction<TreeUrlState | null>>];

package/components/basic/tree/hooks/useTreePersistedState.js

@@ -0,0 +1,38 @@
+import { useCallback, useEffect, useState } from "react";
+import { getTreeState, saveTreeState } from "../utils";
+const storageType = (statehandler) => {
+  if (statehandler === "localStorage" || statehandler === "sessionStorage" || statehandler === "URL") {
+    return statehandler;
+  }
+  return null;
+};
+function useTreePersistedState(name, statehandler) {
+  const storage = storageType(statehandler);
+  const [persisted, setPersisted] = useState(null);
+  useEffect(() => {
+    if (!storage || typeof window === "undefined") {
+      setPersisted(null);
+      return;
+    }
+    try {
+      setPersisted(getTreeState(name, storage));
+    } catch (e) {
+      setPersisted(null);
+    }
+  }, [name, storage]);
+  const setPersistedState = useCallback(
+    (update) => {
+      if (!storage) return;
+      setPersisted((prev) => {
+        const next = typeof update === "function" ? update(prev) : update;
+        saveTreeState(name, storage, next);
+        return next;
+      });
+    },
+    [name, storage]
+  );
+  return [persisted, setPersistedState];
+}
+export {
+  useTreePersistedState
+};

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

@@ -30,6 +30,7 @@ declare const _default: React.ComponentType<{
     onSelect?: (event: React.MouseEvent, widget: any, item: any, path: string) => void;
     onCheck?: (event: React.MouseEvent, widget: any, item: any, checked: boolean) => void;
     template?: string;
+    statehandler?: string;
     standalone?: boolean;
     ref?: React.RefObject<HTMLElement> | React.RefObject<null>;
     animation?: string;
@@ -79,5 +80,7 @@ declare const _default: React.ComponentType<{
     updateon?: string;
     dataset?: any;
     prefabName?: string;
+    loading?: boolean;
+    showSkeleton?: boolean;
 }>;
 export default _default;

package/components/basic/tree/index.js

@@ -17,6 +17,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 import { jsx } from "react/jsx-runtime";
 import { useState, useEffect, useMemo, useCallback, useRef } from "react";
 import clsx from "clsx";
@@ -34,11 +46,16 @@ import {
   generateUniqueNodeId,
   findNodeById,
   toggleExpansionInTree,
-  isTreeNodeDisabled
+  isTreeNodeDisabled,
+  migrateLegacyTreeUrlState,
+  normalizeExpandedIds,
+  collectExpandedNodeIdsForUrl
 } from "./utils";
 import { useCustomTemplate } from "../../common/customTemplate";
+import { useTreePersistedState } from "./hooks/useTreePersistedState";
 const DEFAULT_CLASS = "app-tree";
 const DEFAULT_TREE_ICON_CLASS = "plus-minus";
+const persistenceEnabledFor = (statehandler) => statehandler === "URL" || statehandler === "localStorage" || statehandler === "sessionStorage";
 const WmTree = (props) => {
   var _a, _b;
   const {
@@ -64,8 +81,11 @@ const WmTree = (props) => {
     listener,
     width,
     height,
-    template
+    template,
+    statehandler
   } = props;
+  const [persistedState, setPersistedState] = useTreePersistedState(name, statehandler);
+  const persistenceEnabled = persistenceEnabledFor(statehandler);
   const isCheckboxTree = (_a = className == null ? void 0 : className.includes("Checkbox")) != null ? _a : false;
   const isRadioTree = (_b = className == null ? void 0 : className.includes("Radio")) != null ? _b : false;
   const [treeNodes, setTreeNodes] = useState([]);
@@ -74,6 +94,7 @@ const WmTree = (props) => {
   const { templateName, setTemplate } = useCustomTemplate({ content: template, name });
   const treeNodesRef = useRef([]);
   treeNodesRef.current = treeNodes;
+  const skipNextPersistRef = useRef(false);
   const usedNodeIds = useRef(/* @__PURE__ */ new Set());
   const getNodesFromString = useCallback(
     (value) => {
@@ -128,7 +149,7 @@ const WmTree = (props) => {
   }, []);
   const toggleNodeExpansion = useCallback(
     (event, node) => {
-      var _a2;
+      var _a2, _b2, _c;
       const ev = event != null ? event : {
         preventDefault: () => {
         },
@@ -144,34 +165,53 @@ const WmTree = (props) => {
       const after_nodeUpdate = findNodeById(updatedNodes, node.nodeId);
       treeNodesRef.current = updatedNodes;
       setTreeNodes(updatedNodes);
+      if (persistenceEnabled) {
+        setPersistedState((prevPersist) => {
+          const base = prevPersist && typeof prevPersist === "object" ? prevPersist : {};
+          return __spreadProps(__spreadValues({}, base), {
+            expanded: collectExpandedNodeIdsForUrl(updatedNodes)
+          });
+        });
+      }
       if (after_nodeUpdate && ev && name) {
         const path = getPath(after_nodeUpdate);
         if (after_nodeUpdate.open) {
           if (onExpand) {
-            onExpand(ev, listener == null ? void 0 : listener.Widgets[name], after_nodeUpdate.data, path);
+            onExpand(ev, (_b2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _b2[name], after_nodeUpdate.data, path);
           }
         } else if (onCollapse) {
-          onCollapse(ev, listener == null ? void 0 : listener.Widgets[name], after_nodeUpdate.data, path);
+          onCollapse(ev, (_c = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _c[name], after_nodeUpdate.data, path);
         }
       }
     },
-    [getPath, name, onCollapse, onExpand]
+    [getPath, name, onCollapse, onExpand, persistenceEnabled]
   );
   const selectNode = useCallback(
     (event, node) => {
-      var _a2, _b2;
+      var _a2, _b2, _c;
       if (!node) return;
       const resolvedTreeNode = (_a2 = findNodeById(treeNodesRef.current, node.nodeId)) != null ? _a2 : node;
       if (isTreeNodeDisabled(resolvedTreeNode.data)) return;
       setSelectedItem(resolvedTreeNode);
+      if (persistenceEnabled && !skipNextPersistRef.current) {
+        setPersistedState((prevPersist) => {
+          const base = prevPersist && typeof prevPersist === "object" ? prevPersist : {};
+          return __spreadProps(__spreadValues({}, base), { selected: resolvedTreeNode.nodeId });
+        });
+      }
       if (event && nodeclick === "expand" && ((_b2 = resolvedTreeNode.children) == null ? void 0 : _b2.length)) {
         toggleNodeExpansion(event, resolvedTreeNode);
       }
       if (onSelect && event && name) {
-        onSelect(event, listener == null ? void 0 : listener.Widgets[name], resolvedTreeNode.data, getPath(resolvedTreeNode));
+        onSelect(
+          event,
+          (_c = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _c[name],
+          resolvedTreeNode.data,
+          getPath(resolvedTreeNode)
+        );
       }
     },
-    [name, nodeclick, onSelect, toggleNodeExpansion]
+    [name, nodeclick, onSelect, toggleNodeExpansion, persistenceEnabled]
   );
   const handleNodeClick = useCallback(
     (event, node) => {
@@ -274,32 +314,41 @@ const WmTree = (props) => {
     (nodeId) => {
       if (!nodeId) {
         setSelectedItem(null);
+        if (persistenceEnabled) {
+          setPersistedState((prevPersist) => {
+            if (!prevPersist || typeof prevPersist !== "object") return prevPersist;
+            const _a2 = prevPersist, { selected: _s } = _a2, rest = __objRest(_a2, ["selected"]);
+            return rest;
+          });
+        }
         return;
       }
       const node = findNodeById(treeNodes, nodeId);
       if (node) {
         if (isTreeNodeDisabled(node.data)) return;
+        skipNextPersistRef.current = true;
         selectNode(void 0, node);
+        skipNextPersistRef.current = false;
+        let working = treeNodesRef.current;
         if (isRadioTree) {
           setRadioSelectedNodeId(node.nodeId);
           const updateRadioState = (nodes, selectedNodeId) => {
-            return nodes.map((node2) => {
+            return nodes.map((n) => {
               var _a2;
-              const isChecked = node2.nodeId === selectedNodeId;
-              const updatedNode = __spreadProps(__spreadValues({}, node2), {
+              const isChecked = n.nodeId === selectedNodeId;
+              const updatedNode = __spreadProps(__spreadValues({}, n), {
                 checked: isChecked
               });
               if (updatedNode.data) {
                 updatedNode.data = __spreadProps(__spreadValues({}, updatedNode.data), { checked: isChecked });
               }
-              if ((_a2 = node2.children) == null ? void 0 : _a2.length) {
-                updatedNode.children = updateRadioState(node2.children, selectedNodeId);
+              if ((_a2 = n.children) == null ? void 0 : _a2.length) {
+                updatedNode.children = updateRadioState(n.children, selectedNodeId);
               }
               return updatedNode;
             });
           };
-          const updatedNodes = updateRadioState(treeNodes, node.nodeId);
-          setTreeNodes(updatedNodes);
+          working = updateRadioState(working, node.nodeId);
         }
         let currentNode = node.parent;
         const nodesToExpand = [];
@@ -308,29 +357,46 @@ const WmTree = (props) => {
           currentNode = currentNode.parent;
         }
         if (nodesToExpand.length) {
-          const updateNodeOpenState = (nodes, nodesToExpand2) => {
-            return nodes.map((node2) => {
+          const updateNodeOpenState = (nodes, toExpand) => {
+            return nodes.map((n) => {
               var _a2;
-              if (nodesToExpand2.some((n) => n.nodeId === node2.nodeId)) {
-                return __spreadProps(__spreadValues({}, node2), {
+              if (toExpand.some((x) => x.nodeId === n.nodeId)) {
+                return __spreadProps(__spreadValues({}, n), {
                   open: true,
-                  children: node2.children ? updateNodeOpenState(node2.children, nodesToExpand2) : void 0
+                  children: n.children ? updateNodeOpenState(n.children, toExpand) : void 0
                 });
-              } else if ((_a2 = node2.children) == null ? void 0 : _a2.length) {
-                return __spreadProps(__spreadValues({}, node2), { children: updateNodeOpenState(node2.children, nodesToExpand2) });
+              } else if ((_a2 = n.children) == null ? void 0 : _a2.length) {
+                return __spreadProps(__spreadValues({}, n), { children: updateNodeOpenState(n.children, toExpand) });
               }
-              return node2;
+              return n;
             });
           };
-          const updatedNodes = updateNodeOpenState(treeNodes, nodesToExpand);
-          setTreeNodes(updatedNodes);
+          working = updateNodeOpenState(working, nodesToExpand);
+        }
+        treeNodesRef.current = working;
+        setTreeNodes(working);
+        if (persistenceEnabled) {
+          setPersistedState((prevPersist) => {
+            const base = prevPersist && typeof prevPersist === "object" ? prevPersist : {};
+            return __spreadProps(__spreadValues({}, base), {
+              selected: node.nodeId,
+              expanded: collectExpandedNodeIdsForUrl(working)
+            });
+          });
         }
       }
     },
-    [isRadioTree, selectNode, treeNodes]
+    [isRadioTree, selectNode, persistenceEnabled, treeNodes]
   );
   const deselectById = useCallback(() => {
     setSelectedItem(null);
+    if (persistenceEnabled) {
+      setPersistedState((prevPersist) => {
+        if (!prevPersist || typeof prevPersist !== "object") return prevPersist;
+        const _a2 = prevPersist, { selected: _s } = _a2, rest = __objRest(_a2, ["selected"]);
+        return rest;
+      });
+    }
     if (isRadioTree) {
       setRadioSelectedNodeId(null);
       const clearCheckedState = (nodes) => {
@@ -348,8 +414,15 @@ const WmTree = (props) => {
       };
       setTreeNodes(clearCheckedState(treeNodes));
     }
-  }, [isRadioTree]);
+  }, [isRadioTree, persistenceEnabled, treeNodes]);
   const sortedTreeNodes = useMemo(() => treeNodes, [treeNodes]);
+  const urlExpansionOverlay = useMemo(() => {
+    if (!persistenceEnabled || !sortedTreeNodes.length || !persistedState) return void 0;
+    const raw = Array.isArray(persistedState.expanded) && persistedState.expanded.length > 0 ? persistedState.expanded.map(String) : migrateLegacyTreeUrlState(persistedState);
+    if (!raw.length) return void 0;
+    return normalizeExpandedIds(sortedTreeNodes, raw);
+  }, [persistenceEnabled, sortedTreeNodes, persistedState]);
+  const urlSelectedId = persistenceEnabled ? persistedState == null ? void 0 : persistedState.selected : void 0;
   const prevDatasetRef = useRef(void 0);
   const prevGetNodesRef = useRef(null);
   useEffect(() => {
@@ -409,7 +482,7 @@ const WmTree = (props) => {
         setTemplate
       });
     }
-  }, [selectById, deselectById]);
+  }, [name]);
   return /* @__PURE__ */ jsx(
     Box,
     {
@@ -438,7 +511,9 @@ const WmTree = (props) => {
           handleRadioSelect,
           treeName: name,
           template: template || templateName,
-          listener
+          listener,
+          urlExpansionOverlay,
+          urlSelectedId
         },
         node.nodeId
       )) : /* @__PURE__ */ jsx("li", { className: "wm-tree-empty-message", children: "No tree data available" })

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/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

@@ -20,6 +20,11 @@ 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;
   const disabled_node = data.disabled;
@@ -144,6 +149,106 @@ const toggleExpansionInTree = (nodes, nodeId) => {
     return n;
   });
 };
+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;
@@ -205,12 +310,18 @@ export {
   assembleTreePartialItem,
   buildTreePartialSnapshot,
   buildTreePathFromRoot,
+  clearTreeState,
+  collectExpandedNodeIdsForUrl,
   computeTreeNodeDepthFromRoot,
   findNodeById,
   generateUniqueNodeId,
   getNestedPropertyLocal,
   getTreePartialRowPayload,
+  getTreeState,
   isTreeNodeDisabled,
+  migrateLegacyTreeUrlState,
+  normalizeExpandedIds,
   processNode,
+  saveTreeState,
   toggleExpansionInTree
 };

package/components/basic/video/index.d.ts

@@ -75,5 +75,7 @@ declare const _default: React.ComponentType<{
     formfield?: boolean;
     updateon?: string;
     dataset?: any;
+    loading?: boolean;
+    showSkeleton?: boolean;
 }>;
 export default _default;

package/components/chart/index.d.ts

@@ -125,5 +125,7 @@ declare const _default: React.ComponentType<{
     formfield?: boolean;
     updateon?: string;
     prefabName?: string;
+    loading?: boolean;
+    showSkeleton?: boolean;
 }>;
 export default _default;

package/components/chart/src/dataUtils.js

@@ -428,7 +428,7 @@ const getAggregatedData = (datasource, groupby, aggregation, aggregationcolumn,
       }
     ];
   }
-  datasource.execute("getAggregatedData", {
+  datasource == null ? void 0 : datasource.execute("getAggregatedData", {
     aggregations: data,
     sort: sortExpr
   }).then(

package/components/common/customTemplate/useCustomTemplate.js

@@ -6,7 +6,7 @@ function useCustomTemplate({ content, name, listener }) {
     if ((listener == null ? void 0 : listener.onChange) && typeof listener.onChange === "function") {
       listener.onChange(name, { setTemplate });
     }
-  }, [name, listener == null ? void 0 : listener.onChange]);
+  }, [name]);
   useEffect(() => {
     stableOnChange();
   }, [stableOnChange]);

package/components/common/index.d.ts

@@ -1 +1,3 @@
 export { AppSpinner } from "./AppSpinner";
+export { WmSkeleton, SKELETON_REGISTRY, shouldShowSkeleton } from "./wm-skeleton";
+export type { WmSkeletonProps, SkeletonConfig } from "./wm-skeleton";

package/components/common/index.js

@@ -1,4 +1,8 @@
 import { AppSpinner } from "./AppSpinner";
+import { WmSkeleton, SKELETON_REGISTRY, shouldShowSkeleton } from "./wm-skeleton";
 export {
-  AppSpinner
+  AppSpinner,
+  SKELETON_REGISTRY,
+  WmSkeleton,
+  shouldShowSkeleton
 };