@wavemaker-ai/react-runtime 1.0.0-next.27766

package/higherOrder/DataNav.js

@@ -0,0 +1,446 @@
+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));
+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 { useRef, useEffect, useMemo, forwardRef, useState } from "react";
+import { flattenDeep } from "lodash";
+const getValidLink = (link) => {
+  if (!link) return void 0;
+  const routRegex = /^(\/|#\/|#)(?!\W).*/;
+  if (routRegex.test(link)) {
+    const match = link.match(/[\w]+.*/);
+    if (match) {
+      link = `${match[0]}`;
+    }
+  } else if (link.startsWith("www.")) {
+    link = `//${link}`;
+  }
+  return link;
+};
+const getElement = (obj, key) => obj && obj[key];
+const validateAccessRoles = (roles, userRoles) => {
+  if (!roles || typeof roles !== "string") return true;
+  const roleList = roles.split(",").map((role) => role.trim());
+  return roleList.some((role) => userRoles.includes(role));
+};
+const createArrayFrom = (value) => {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value ? [value] : [];
+};
+const getOrderedDataset = (dataset, orderby) => {
+  if (!orderby) return dataset;
+  const [field, direction] = orderby.split(":");
+  return dataset.sort((a, b) => {
+    const valA = a[field] || a.label || a.value || a;
+    const valB = b[field] || b.label || b.value || b;
+    let comparison = 0;
+    if (valA < valB) comparison = -1;
+    if (valA > valB) comparison = 1;
+    return direction === "desc" ? -comparison : comparison;
+  });
+};
+const getEvaluatedData = (dataObj, options, context) => {
+  if (options.bindExpression) {
+    return options.bindExpression(context, dataObj);
+  }
+  if (options.field) {
+    return dataObj[options.field];
+  }
+  return void 0;
+};
+const getCurrentRouteId = () => {
+  const path = window.location.pathname.substr(1).split("?")[0];
+  const segments = path.split("/");
+  return segments[segments.length - 1] || "Main";
+};
+const findPathToNode = (nodes, targetId, path = []) => {
+  var _a;
+  for (const node of nodes) {
+    if (node.id === targetId) {
+      return [...path, node];
+    }
+    if ((_a = node.children) == null ? void 0 : _a.length) {
+      const foundPath = findPathToNode(node.children, targetId, [...path, node]);
+      if (foundPath.length) {
+        return foundPath;
+      }
+    }
+  }
+  return [];
+};
+const findNodeById = (data, targetId, itemIdField = "id") => {
+  for (const item of data) {
+    if (item && typeof item === "object") {
+      if (item[itemIdField] === targetId) {
+        return true;
+      }
+      if (Array.isArray(item.children) && item.children.length > 0) {
+        if (findNodeById(item.children, targetId, itemIdField)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};
+const findMatchingDataset = (data, currentRouteId, itemIdField = "id") => {
+  if (!Array.isArray(data) || data.length === 0) {
+    return data || [];
+  }
+  if (!Array.isArray(data[0])) {
+    return data;
+  }
+  for (let i = 0; i < data.length; i++) {
+    const arrayItem = data[i];
+    const flattenedArray = flattenDeep([arrayItem]);
+    if (flattenedArray.length > 0 && findNodeById(flattenedArray, currentRouteId, itemIdField)) {
+      return flattenedArray;
+    }
+  }
+  const fallbackArray = flattenDeep([data[0]]);
+  return fallbackArray.length > 0 ? fallbackArray : data;
+};
+const handleNavigation = (item, event, options = {}) => {
+  const { onBeforenavigate, defaultTarget } = options;
+  event.preventDefault();
+  const locals = { $item: item.value, $event: event };
+  const canNavigate = !((onBeforenavigate == null ? void 0 : onBeforenavigate(locals)) === false);
+  const linkTarget = item.target || defaultTarget;
+  let itemLink = item.link;
+  if (itemLink && canNavigate) {
+    const queryString = itemLink.split("?")[1];
+    const cleanPath = itemLink.replace(/^#?\/?/, "").split("?")[0];
+    const currentPath = window.location.pathname;
+    const pathSegments = currentPath.split("/");
+    if (pathSegments.length > 1) {
+      pathSegments[pathSegments.length - 1] = cleanPath;
+      const newPath = pathSegments.join("/") + (queryString ? `?${queryString}` : "");
+      window.location.href = newPath;
+    } else {
+      window.location.href = `/${cleanPath}${queryString ? `?${queryString}` : ""}`;
+    }
+  }
+};
+const withDatasetAwareNavigation = (WrappedComponent) => {
+  const NavigationWrappedComponent = forwardRef((props, ref) => {
+    var _b, _c;
+    const _a = props, {
+      itemicon,
+      itemlabel,
+      itemhint,
+      itemlink,
+      itemtarget,
+      itembadge,
+      itemchildren,
+      itemaction,
+      itemclass,
+      itemid,
+      isactive,
+      userrole,
+      orderby,
+      datafield,
+      displayfield,
+      listener,
+      styles,
+      className
+    } = _a, restProps = __objRest(_a, [
+      "itemicon",
+      "itemlabel",
+      "itemhint",
+      "itemlink",
+      "itemtarget",
+      "itembadge",
+      "itemchildren",
+      "itemaction",
+      "itemclass",
+      "itemid",
+      "isactive",
+      "userrole",
+      "orderby",
+      "datafield",
+      "displayfield",
+      "listener",
+      "styles",
+      "className"
+    ]);
+    const dataset = useMemo(() => {
+      let data = typeof props.dataset === "function" ? props.dataset() : props.dataset;
+      if (Array.isArray(data) && data.length > 0 && Array.isArray(data[0])) {
+        const currentRouteId = getCurrentRouteId();
+        const itemIdField = itemid || "id";
+        data = findMatchingDataset(data, currentRouteId, itemIdField);
+      }
+      return data || [];
+    }, [props.dataset, itemid]);
+    const [navNodes, setNavNodes] = useState([]);
+    const securityService = ((_b = listener == null ? void 0 : listener.appConfig) == null ? void 0 : _b.SecurityService) || { loggedInUser: [] };
+    const userRoles = ((_c = securityService.loggedInUser) == null ? void 0 : _c.roles) || [];
+    const binditemlabel = useRef(null);
+    const binditemhint = useRef(null);
+    const binditemicon = useRef(null);
+    const binditemaction = useRef(null);
+    const binditembadge = useRef(null);
+    const binditemchildren = useRef(null);
+    const binditemid = useRef(null);
+    const binditemlink = useRef(null);
+    const binditemtarget = useRef(null);
+    const binduserrole = useRef(null);
+    const bindisactive = useRef(null);
+    const _itemFieldMap = useRef({
+      idField: itemid || "id",
+      iconField: itemicon || "icon",
+      labelField: itemlabel || "label",
+      hintField: itemhint || "hint",
+      linkField: itemlink || "link",
+      targetField: itemtarget || "target",
+      badgeField: itembadge || "badge",
+      childrenField: itemchildren || "children",
+      classField: itemclass || "class",
+      actionField: itemaction || "action",
+      isactiveField: isactive || "isactive",
+      roleField: userrole || "role"
+    });
+    useEffect(() => {
+      var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i, _j, _k;
+      const r = restProps;
+      binditemlabel.current = (_a2 = r["itemlabel.bind"]) != null ? _a2 : null;
+      binditemhint.current = (_b2 = r["itemhint.bind"]) != null ? _b2 : null;
+      binditemicon.current = (_c2 = r["itemicon.bind"]) != null ? _c2 : null;
+      binditemaction.current = (_d = r["itemaction.bind"]) != null ? _d : null;
+      binditembadge.current = (_e = r["itembadge.bind"]) != null ? _e : null;
+      binditemchildren.current = (_f = r["itemchildren.bind"]) != null ? _f : null;
+      binditemid.current = (_g = r["itemid.bind"]) != null ? _g : null;
+      binditemlink.current = (_h = r["itemlink.bind"]) != null ? _h : null;
+      binditemtarget.current = (_i = r["itemtarget.bind"]) != null ? _i : null;
+      binduserrole.current = (_j = r["userrole.bind"]) != null ? _j : null;
+      bindisactive.current = (_k = r["isactive.bind"]) != null ? _k : null;
+    }, [restProps]);
+    useEffect(() => {
+      resetNodes();
+    }, [
+      dataset,
+      itemicon,
+      itemlabel,
+      itemhint,
+      itemlink,
+      itemtarget,
+      itembadge,
+      itemchildren,
+      itemaction,
+      itemclass,
+      itemid,
+      isactive,
+      userrole,
+      orderby,
+      datafield,
+      displayfield
+    ]);
+    const resetItemFieldMap = () => {
+      _itemFieldMap.current = {
+        idField: itemid || "id",
+        iconField: itemicon || "icon",
+        labelField: itemlabel || "label",
+        hintField: itemhint || "hint",
+        linkField: itemlink || "link",
+        targetField: itemtarget || "target",
+        badgeField: itembadge || "badge",
+        childrenField: itemchildren || "children",
+        classField: itemclass || "class",
+        actionField: itemaction || "action",
+        isactiveField: isactive || "isactive",
+        roleField: userrole || "role"
+      };
+    };
+    const getNode = (fields, node) => {
+      const context = {};
+      let processedNode;
+      if (typeof node === "string") {
+        processedNode = {
+          label: node,
+          value: node,
+          expanded: false
+        };
+      } else if (typeof node === "object") {
+        const childrenData = getElement(node, fields.childrenField);
+        const children = Array.isArray(childrenData) ? childrenData.map((child) => getNode(fields, child)) : [];
+        processedNode = {
+          action: getEvaluatedData(
+            node,
+            { field: itemaction, bindExpression: binditemaction.current },
+            context
+          ) || getElement(node, fields.actionField),
+          badge: getEvaluatedData(
+            node,
+            { field: itembadge, bindExpression: binditembadge.current },
+            context
+          ) || getElement(node, fields.badgeField),
+          children,
+          class: getElement(node, fields.classField),
+          disabled: node.disabled,
+          icon: getEvaluatedData(
+            node,
+            { field: itemicon, bindExpression: binditemicon.current },
+            context
+          ) || getElement(node, fields.iconField),
+          id: getEvaluatedData(
+            node,
+            { field: itemid, bindExpression: binditemid.current },
+            context
+          ) || getElement(node, fields.idField),
+          label: getEvaluatedData(
+            node,
+            { field: itemlabel, bindExpression: binditemlabel.current },
+            context
+          ) || getElement(node, fields.labelField) || node.label || String(node),
+          hint: getEvaluatedData(
+            node,
+            { field: itemhint, bindExpression: binditemhint.current },
+            context
+          ) || getElement(node, fields.hintField),
+          link: getValidLink(
+            getEvaluatedData(
+              node,
+              { field: itemlink, bindExpression: binditemlink.current },
+              context
+            ) || getElement(node, fields.linkField)
+          ) || node.link,
+          target: getEvaluatedData(
+            node,
+            { field: itemtarget, bindExpression: binditemtarget.current },
+            context
+          ) || getElement(node, fields.targetField),
+          role: getEvaluatedData(
+            node,
+            { field: userrole, bindExpression: binduserrole.current },
+            context
+          ) || getElement(node, fields.roleField),
+          isactive: getEvaluatedData(
+            node,
+            { field: isactive, bindExpression: bindisactive.current },
+            context
+          ) || getElement(node, fields.isactiveField),
+          value: datafield && datafield !== "All Fields" ? getElement(node, datafield) : node,
+          expanded: false
+        };
+      } else {
+        processedNode = {
+          label: String(node),
+          value: node,
+          expanded: false
+        };
+      }
+      return processedNode;
+    };
+    const prepareNodeDataSet = (nv) => {
+      if (!nv) return [];
+      if (typeof nv === "string") {
+        const items = nv.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+        return items.map((item) => ({
+          label: item,
+          value: item
+        }));
+      }
+      if (nv && typeof nv === "object" && !Array.isArray(nv)) {
+        return Object.entries(nv).map(([key, value]) => ({
+          label: String(value),
+          value: key,
+          key
+        }));
+      }
+      const arrayData = createArrayFrom(nv);
+      return arrayData.map((val) => {
+        if (typeof val === "string") {
+          return {
+            label: val,
+            value: val
+          };
+        }
+        if (typeof val !== "object") {
+          return {
+            label: String(val),
+            value: val
+          };
+        }
+        return val;
+      });
+    };
+    const getNodes = (nv = dataset || []) => {
+      if (!nv || Array.isArray(nv) && nv.length === 0) {
+        return [];
+      }
+      let nodes = getOrderedDataset(prepareNodeDataSet(nv), orderby) || [];
+      if (nodes.length) {
+        const nodeFields = _itemFieldMap.current;
+        nodes = nodes.reduce((result, node) => {
+          if (validateAccessRoles(getElement(node, nodeFields.roleField), userRoles)) {
+            result.push(getNode(nodeFields, node));
+          }
+          return result;
+        }, []);
+      }
+      return nodes;
+    };
+    const resetNodes = () => {
+      resetItemFieldMap();
+      const newNodes = getNodes();
+      setNavNodes(newNodes);
+    };
+    const filteredNavNodes = useMemo(() => {
+      if (!navNodes || navNodes.length === 0) {
+        return navNodes;
+      }
+      const currentRouteId = getCurrentRouteId();
+      if (!currentRouteId) {
+        return [];
+      }
+      const breadcrumbPath = findPathToNode(navNodes, currentRouteId);
+      return breadcrumbPath.length > 0 ? breadcrumbPath : [];
+    }, [navNodes]);
+    return /* @__PURE__ */ jsx(
+      WrappedComponent,
+      __spreadProps(__spreadValues({}, props), {
+        ref,
+        navNodes: filteredNavNodes,
+        resetNavNodes: resetNodes,
+        handleNavigation
+      })
+    );
+  });
+  NavigationWrappedComponent.displayName = `withDatasetAwareNavigation(${WrappedComponent.displayName || WrappedComponent.name || "Component"})`;
+  return NavigationWrappedComponent;
+};
+var DataNav_default = withDatasetAwareNavigation;
+export {
+  DataNav_default as default,
+  handleNavigation
+};

package/higherOrder/helper.d.ts

@@ -0,0 +1,32 @@
+import { getCurrentMonth, reload } from "@/core/util";
+import moment from "moment-timezone";
+export declare const mergeVariablesAndActions: (pageVariables: {
+    Variables: Record<string, any>;
+    Actions: Record<string, any>;
+}, appVars?: {
+    Variables: Record<string, any>;
+    Actions: Record<string, any>;
+}) => {
+    Variables: {
+        [x: string]: any;
+    };
+    Actions: {
+        [x: string]: any;
+    };
+};
+export declare const BaseAppInitialState: {
+    activePageName: string;
+    lastActivePage: string;
+    Variables: {};
+    Actions: {};
+    isAppReady: boolean;
+    getDependency: (t: string) => any;
+    getCurrentMonth: typeof getCurrentMonth;
+    notification: any;
+    Common: {};
+    onPageReady: () => void;
+    reload: typeof reload;
+};
+export declare function importModule(moduleName: string): typeof moment;
+export declare const accordionExpansionHandler: (pageProxyRef: React.RefObject<any>, pendingAccordionExpansion: any, dispatch: any) => void;
+export declare const tabSelectionHandler: (pageProxyRef: React.RefObject<any>, tabNameToSelect: any, dispatch: any) => void;

package/higherOrder/helper.js

@@ -0,0 +1,95 @@
+var __defProp = Object.defineProperty;
+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;
+};
+import appstore from "../core/appstore";
+import { getCurrentMonth, reload, getTimezone } from "../core/util";
+import moment from "moment-timezone";
+import {
+  clearPendingAccordionExpansion,
+  clearPendingTabSelection
+} from "../store/slices/navigationSlice";
+const mergeVariablesAndActions = (pageVariables, appVars = {
+  Variables: {},
+  Actions: {}
+}) => {
+  return {
+    Variables: __spreadValues(__spreadValues({}, appVars.Variables), pageVariables.Variables),
+    Actions: __spreadValues(__spreadValues({}, appVars.Actions), pageVariables.Actions)
+  };
+};
+const BaseAppInitialState = {
+  activePageName: "",
+  lastActivePage: "",
+  Variables: {},
+  Actions: {},
+  isAppReady: false,
+  getDependency: appstore.getDependency,
+  getCurrentMonth,
+  notification: null,
+  Common: {},
+  onPageReady: () => {
+  },
+  reload
+};
+function importModule(moduleName) {
+  if (moduleName === "moment") {
+    const locale = getTimezone();
+    const guessedTz = locale || moment.tz && typeof moment.tz.guess === "function" && moment.tz.guess() || typeof Intl !== "undefined" && Intl.DateTimeFormat && Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    if (moment.tz && typeof moment.tz.setDefault === "function") {
+      moment.tz.setDefault(guessedTz);
+    }
+    return moment;
+  }
+}
+const accordionExpansionHandler = (pageProxyRef, pendingAccordionExpansion, dispatch) => {
+  setTimeout(() => {
+    var _a, _b, _c;
+    try {
+      if ((_c = (_b = (_a = pageProxyRef.current) == null ? void 0 : _a.Widgets) == null ? void 0 : _b[pendingAccordionExpansion]) == null ? void 0 : _c.expand) {
+        pageProxyRef.current.Widgets[pendingAccordionExpansion].expand();
+      } else {
+        console.warn(`Accordion widget not found: ${pendingAccordionExpansion}`);
+      }
+    } catch (error) {
+      console.warn(`Unable to expand accordion: ${pendingAccordionExpansion}`, error);
+    } finally {
+      dispatch(clearPendingAccordionExpansion());
+    }
+  }, 0);
+};
+const tabSelectionHandler = (pageProxyRef, tabNameToSelect, dispatch) => {
+  setTimeout(() => {
+    var _a, _b, _c;
+    try {
+      if ((_c = (_b = (_a = pageProxyRef.current) == null ? void 0 : _a.Widgets) == null ? void 0 : _b[tabNameToSelect]) == null ? void 0 : _c.select) {
+        pageProxyRef.current.Widgets[tabNameToSelect].select();
+      } else {
+        console.warn(`Tab widget not found: ${tabNameToSelect}`);
+      }
+    } catch (error) {
+      console.warn(`Unable to select tab: ${tabNameToSelect}`, error);
+    } finally {
+      dispatch(clearPendingTabSelection());
+    }
+  }, 0);
+};
+export {
+  BaseAppInitialState,
+  accordionExpansionHandler,
+  importModule,
+  mergeVariablesAndActions,
+  tabSelectionHandler
+};

package/higherOrder/props.d.ts

@@ -0,0 +1,127 @@
+import { CSSProperties } from "react";
+/**
+ * Helper type to flatten intersection types for better VS Code intellisense.
+ */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export interface Props {
+    standalone?: boolean;
+    ref?: React.RefObject<HTMLElement> | React.RefObject<null>;
+    animation?: string;
+    show?: boolean | string;
+    padding?: string;
+    margin?: string;
+    width?: number | string;
+    height?: number | string;
+    className?: string;
+    conditionalstyle?: CSSProperties;
+    conditionalclass?: string;
+    showindevice?: ("xs" | "sm" | "md" | "lg" | "all")[];
+    onClick?: (event?: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onDoubleClick?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseEnter?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseLeave?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseOver?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseOut?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onFocus?: (event: React.FocusEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onBlur?: (event: React.FocusEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onKeydown?: (event: React.KeyboardEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onKeyup?: (event: React.KeyboardEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onKeypress?: (event: React.KeyboardEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    /**
+     * Internal WaveMaker event callback.
+     */
+    eventCallback?: (eventName: string, data: any) => void;
+    /**
+     * Ref forwarded by WaveMaker wrapper.
+     */
+    forwardedRef?: React.ForwardedRef<any>;
+    /**
+     * The proxy/viewParent for the widget.
+     */
+    viewParent?: any;
+    destroy?: ((names: string[]) => void) | ((formName?: string) => void);
+    hint?: string;
+    arialabel?: string;
+    tabindex?: number;
+    styles?: CSSProperties;
+    children?: React.ReactNode;
+    hidden?: boolean;
+    id?: string;
+    /**
+     * The unique name of the widget.
+     */
+    name?: string;
+    listener?: Record<string, any>;
+    "data-widget-id"?: string;
+    iswidget?: boolean | string;
+    deferload?: boolean | string;
+    "item-id"?: string;
+    datavalue?: any;
+    prefab?: boolean;
+    inbound?: Record<string, any>;
+    outbound?: Record<string, any>;
+    key?: string;
+    formfield?: boolean;
+    updateon?: string;
+    dataset?: any;
+    prefabName?: string;
+    /**
+     * When true, indicates that the widget's data is being loaded.
+     * Used together with `showSkeleton` to display a skeleton placeholder.
+     */
+    loading?: boolean;
+    /**
+     * Optional runtime opt-out for skeleton display while loading.
+     * Not emitted by codegen — omit (default) to show skeleton when `loading` is true.
+     */
+    showSkeleton?: boolean;
+    widget?: string;
+}
+/**
+ * Interface for props injected by the BaseDialog (withDialogWrapper) HOC.
+ */
+export interface WmDialogInjectedProps {
+    /**
+     * Whether the dialog is currently open.
+     */
+    isopen?: boolean;
+    /**
+     * Closes the dialog.
+     */
+    close?: (event?: React.SyntheticEvent) => void;
+    /**
+     * Opens the dialog.
+     */
+    openDialog?: (event?: React.SyntheticEvent) => void;
+    /**
+     * Closes the dialog.
+     */
+    closeDialog?: (event?: React.SyntheticEvent) => void;
+    /**
+     * Callback for the OK button click.
+     */
+    onOkClick?: (event?: React.SyntheticEvent) => void;
+    /**
+     * Callback for when the dialog transition has entered.
+     */
+    onTransitionEntered?: () => void;
+    /**
+     * Locale data for the dialog.
+     */
+    dialogLocale?: {
+        LABEL_CLOSE: string;
+    };
+    /**
+     * Widget type discriminator.
+     */
+    widgetType?: string;
+    /**
+     * Whether the component is a dialog.
+     */
+    isDialog?: boolean;
+}
+export interface BaseProps extends Props {
+}
+export default Props;