@wavemaker-ai/react-runtime 1.0.0-rc.309

package/higherOrder/DataNav.js

@@ -0,0 +1,461 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleNavigation = exports["default"] = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+var _lodash = require("lodash");
+var _excluded = ["itemicon", "itemlabel", "itemhint", "itemlink", "itemtarget", "itembadge", "itemchildren", "itemaction", "itemclass", "itemid", "isactive", "userrole", "orderby", "datafield", "displayfield", "listener", "styles", "className"];
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof3(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var __jsx = _react["default"].createElement;
+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; }
+var getValidLink = function getValidLink(link) {
+  if (!link) return undefined;
+  var routRegex = /^(\/|#\/|#)(?!\W).*/;
+  if (routRegex.test(link)) {
+    var match = link.match(/[\w]+.*/);
+    if (match) {
+      link = "".concat(match[0]);
+    }
+  } else if (link.startsWith("www.")) {
+    link = "//".concat(link);
+  }
+  return link;
+};
+var getElement = function getElement(obj, key) {
+  return obj && obj[key];
+};
+var validateAccessRoles = function validateAccessRoles(roles, userRoles) {
+  if (!roles || typeof roles !== "string") return true;
+  var roleList = roles.split(",").map(function (role) {
+    return role.trim();
+  });
+  return roleList.some(function (role) {
+    return userRoles.includes(role);
+  });
+};
+var createArrayFrom = function createArrayFrom(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value ? [value] : [];
+};
+var getOrderedDataset = function getOrderedDataset(dataset, orderby) {
+  if (!orderby) return dataset;
+  var _orderby$split = orderby.split(":"),
+    _orderby$split2 = (0, _slicedToArray2["default"])(_orderby$split, 2),
+    field = _orderby$split2[0],
+    direction = _orderby$split2[1];
+  return dataset.sort(function (a, b) {
+    var valA = a[field] || a.label || a.value || a;
+    var valB = b[field] || b.label || b.value || b;
+    var comparison = 0;
+    if (valA < valB) comparison = -1;
+    if (valA > valB) comparison = 1;
+    return direction === "desc" ? -comparison : comparison;
+  });
+};
+var getEvaluatedData = function getEvaluatedData(dataObj, options, context) {
+  if (options.bindExpression) {
+    return options.bindExpression(context, dataObj);
+  }
+  if (options.field) {
+    return dataObj[options.field];
+  }
+  return undefined;
+};
+var getCurrentRouteId = function getCurrentRouteId() {
+  var path = window.location.pathname.substr(1).split("?")[0];
+  var segments = path.split("/");
+  return segments[segments.length - 1] || "Main";
+};
+var _findPathToNode = function findPathToNode(nodes, targetId) {
+  var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var _iterator = _createForOfIteratorHelper(nodes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _node$children;
+      var node = _step.value;
+      if (node.id === targetId) {
+        return [].concat((0, _toConsumableArray2["default"])(path), [node]);
+      }
+      if ((_node$children = node.children) !== null && _node$children !== void 0 && _node$children.length) {
+        var foundPath = _findPathToNode(node.children, targetId, [].concat((0, _toConsumableArray2["default"])(path), [node]));
+        if (foundPath.length) {
+          return foundPath;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return [];
+};
+var _findNodeById = function findNodeById(data, targetId) {
+  var itemIdField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "id";
+  var _iterator2 = _createForOfIteratorHelper(data),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var item = _step2.value;
+      if (item && (0, _typeof2["default"])(item) === "object") {
+        // Check if current item matches the target id
+        if (item[itemIdField] === targetId) {
+          return true;
+        }
+        // Recursively check children
+        if (Array.isArray(item.children) && item.children.length > 0) {
+          if (_findNodeById(item.children, targetId, itemIdField)) {
+            return true;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return false;
+};
+
+// Helper function to find the correct array from array of arrays based on current route
+var findMatchingDataset = function findMatchingDataset(data, currentRouteId) {
+  var itemIdField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "id";
+  if (!Array.isArray(data) || data.length === 0) {
+    return data || [];
+  }
+
+  // If the first element is not an array, return as is
+  if (!Array.isArray(data[0])) {
+    return data;
+  }
+
+  // It's an array of arrays - search through each array
+  for (var i = 0; i < data.length; i++) {
+    var arrayItem = data[i];
+
+    // Flatten the array item to get all objects regardless of nesting using lodash
+    var flattenedArray = (0, _lodash.flattenDeep)([arrayItem]);
+    if (flattenedArray.length > 0 && _findNodeById(flattenedArray, currentRouteId, itemIdField)) {
+      return flattenedArray;
+    }
+  }
+
+  // If no match found, flatten and return the first array as fallback
+  var fallbackArray = (0, _lodash.flattenDeep)([data[0]]);
+  return fallbackArray.length > 0 ? fallbackArray : data;
+};
+var handleNavigation = exports.handleNavigation = function handleNavigation(item, event) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var onBeforenavigate = options.onBeforenavigate,
+    defaultTarget = options.defaultTarget;
+  event.preventDefault();
+  var locals = {
+    $item: item.value,
+    $event: event
+  };
+  var canNavigate = !((onBeforenavigate === null || onBeforenavigate === void 0 ? void 0 : onBeforenavigate(locals)) === false);
+  var linkTarget = item.target || defaultTarget;
+  var itemLink = item.link;
+  if (itemLink && canNavigate) {
+    var queryString = itemLink.split("?")[1];
+    var cleanPath = itemLink.replace(/^#?\/?/, "").split("?")[0];
+    var currentPath = window.location.pathname;
+    var pathSegments = currentPath.split("/");
+    if (pathSegments.length > 1) {
+      pathSegments[pathSegments.length - 1] = cleanPath;
+      var newPath = pathSegments.join("/") + (queryString ? "?".concat(queryString) : "");
+      window.location.href = newPath;
+    } else {
+      window.location.href = "/".concat(cleanPath).concat(queryString ? "?".concat(queryString) : "");
+    }
+  }
+};
+var withDatasetAwareNavigation = function withDatasetAwareNavigation(WrappedComponent) {
+  var NavigationWrappedComponent = /*#__PURE__*/(0, _react.forwardRef)(function (props, ref) {
+    var _listener$appConfig, _securityService$logg;
+    var itemicon = props.itemicon,
+      itemlabel = props.itemlabel,
+      itemhint = props.itemhint,
+      itemlink = props.itemlink,
+      itemtarget = props.itemtarget,
+      itembadge = props.itembadge,
+      itemchildren = props.itemchildren,
+      itemaction = props.itemaction,
+      itemclass = props.itemclass,
+      itemid = props.itemid,
+      isactive = props.isactive,
+      userrole = props.userrole,
+      orderby = props.orderby,
+      datafield = props.datafield,
+      displayfield = props.displayfield,
+      listener = props.listener,
+      styles = props.styles,
+      className = props.className,
+      restProps = (0, _objectWithoutProperties2["default"])(props, _excluded);
+    var dataset = (0, _react.useMemo)(function () {
+      var data = typeof props.dataset === "function" ? props.dataset() : props.dataset;
+
+      // Handle array of arrays by finding the correct array based on current route
+      if (Array.isArray(data) && data.length > 0 && Array.isArray(data[0])) {
+        var currentRouteId = getCurrentRouteId();
+        var itemIdField = itemid || "id";
+        data = findMatchingDataset(data, currentRouteId, itemIdField);
+      }
+      return data || [];
+    }, [props.dataset, itemid]);
+    var _useState = (0, _react.useState)([]),
+      navNodes = _useState[0],
+      setNavNodes = _useState[1];
+    var securityService = (listener === null || listener === void 0 || (_listener$appConfig = listener.appConfig) === null || _listener$appConfig === void 0 ? void 0 : _listener$appConfig.SecurityService) || {
+      loggedInUser: []
+    };
+    var userRoles = ((_securityService$logg = securityService.loggedInUser) === null || _securityService$logg === void 0 ? void 0 : _securityService$logg.roles) || [];
+    var binditemlabel = (0, _react.useRef)(null);
+    var binditemhint = (0, _react.useRef)(null);
+    var binditemicon = (0, _react.useRef)(null);
+    var binditemaction = (0, _react.useRef)(null);
+    var binditembadge = (0, _react.useRef)(null);
+    var binditemchildren = (0, _react.useRef)(null);
+    var binditemid = (0, _react.useRef)(null);
+    var binditemlink = (0, _react.useRef)(null);
+    var binditemtarget = (0, _react.useRef)(null);
+    var binduserrole = (0, _react.useRef)(null);
+    var bindisactive = (0, _react.useRef)(null);
+    var _itemFieldMap = (0, _react.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"
+    });
+    (0, _react.useEffect)(function () {
+      var _r$itemlabelBind, _r$itemhintBind, _r$itemiconBind, _r$itemactionBind, _r$itembadgeBind, _r$itemchildrenBind, _r$itemidBind, _r$itemlinkBind, _r$itemtargetBind, _r$userroleBind, _r$isactiveBind;
+      var r = restProps;
+      binditemlabel.current = (_r$itemlabelBind = r["itemlabel.bind"]) !== null && _r$itemlabelBind !== void 0 ? _r$itemlabelBind : null;
+      binditemhint.current = (_r$itemhintBind = r["itemhint.bind"]) !== null && _r$itemhintBind !== void 0 ? _r$itemhintBind : null;
+      binditemicon.current = (_r$itemiconBind = r["itemicon.bind"]) !== null && _r$itemiconBind !== void 0 ? _r$itemiconBind : null;
+      binditemaction.current = (_r$itemactionBind = r["itemaction.bind"]) !== null && _r$itemactionBind !== void 0 ? _r$itemactionBind : null;
+      binditembadge.current = (_r$itembadgeBind = r["itembadge.bind"]) !== null && _r$itembadgeBind !== void 0 ? _r$itembadgeBind : null;
+      binditemchildren.current = (_r$itemchildrenBind = r["itemchildren.bind"]) !== null && _r$itemchildrenBind !== void 0 ? _r$itemchildrenBind : null;
+      binditemid.current = (_r$itemidBind = r["itemid.bind"]) !== null && _r$itemidBind !== void 0 ? _r$itemidBind : null;
+      binditemlink.current = (_r$itemlinkBind = r["itemlink.bind"]) !== null && _r$itemlinkBind !== void 0 ? _r$itemlinkBind : null;
+      binditemtarget.current = (_r$itemtargetBind = r["itemtarget.bind"]) !== null && _r$itemtargetBind !== void 0 ? _r$itemtargetBind : null;
+      binduserrole.current = (_r$userroleBind = r["userrole.bind"]) !== null && _r$userroleBind !== void 0 ? _r$userroleBind : null;
+      bindisactive.current = (_r$isactiveBind = r["isactive.bind"]) !== null && _r$isactiveBind !== void 0 ? _r$isactiveBind : null;
+    }, [restProps]);
+    (0, _react.useEffect)(function () {
+      resetNodes();
+    }, [dataset, itemicon, itemlabel, itemhint, itemlink, itemtarget, itembadge, itemchildren, itemaction, itemclass, itemid, isactive, userrole, orderby, datafield, displayfield]);
+    var resetItemFieldMap = function 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"
+      };
+    };
+    var _getNode = function getNode(fields, node) {
+      var context = {};
+
+      // Handle different node structures
+      var processedNode;
+      if (typeof node === "string") {
+        processedNode = {
+          label: node,
+          value: node,
+          expanded: false
+        };
+      } else if ((0, _typeof2["default"])(node) === "object") {
+        var childrenData = getElement(node, fields.childrenField);
+        var children = Array.isArray(childrenData) ? childrenData.map(function (child) {
+          return _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: 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;
+    };
+    var prepareNodeDataSet = function prepareNodeDataSet(nv) {
+      if (!nv) return [];
+
+      // Handle comma-separated string
+      if (typeof nv === "string") {
+        var items = nv.split(",").map(function (item) {
+          return item.trim();
+        }).filter(function (item) {
+          return item.length > 0;
+        });
+        return items.map(function (item) {
+          return {
+            label: item,
+            value: item
+          };
+        });
+      }
+
+      // Handle plain object (convert to array of key-value pairs)
+      if (nv && (0, _typeof2["default"])(nv) === "object" && !Array.isArray(nv)) {
+        return Object.entries(nv).map(function (_ref) {
+          var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+            key = _ref2[0],
+            value = _ref2[1];
+          return {
+            label: String(value),
+            value: key,
+            key: key
+          };
+        });
+      }
+
+      // Handle array
+      var arrayData = createArrayFrom(nv);
+      return arrayData.map(function (val) {
+        if (typeof val === "string") {
+          return {
+            label: val,
+            value: val
+          };
+        }
+        if ((0, _typeof2["default"])(val) !== "object") {
+          return {
+            label: String(val),
+            value: val
+          };
+        }
+        return val;
+      });
+    };
+    var getNodes = function getNodes() {
+      var nv = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : dataset || [];
+      if (!nv || Array.isArray(nv) && nv.length === 0) {
+        return [];
+      }
+      var nodes = getOrderedDataset(prepareNodeDataSet(nv), orderby) || [];
+      if (nodes.length) {
+        var nodeFields = _itemFieldMap.current;
+        nodes = nodes.reduce(function (result, node) {
+          if (validateAccessRoles(getElement(node, nodeFields.roleField), userRoles)) {
+            result.push(_getNode(nodeFields, node));
+          }
+          return result;
+        }, []);
+      }
+      return nodes;
+    };
+    var resetNodes = function resetNodes() {
+      resetItemFieldMap();
+      var newNodes = getNodes();
+      setNavNodes(newNodes);
+    };
+
+    // Check if the wrapped component is a breadcrumb component
+    // Filter navNodes for breadcrumb components to show only path to current page
+    var filteredNavNodes = (0, _react.useMemo)(function () {
+      if (!navNodes || navNodes.length === 0) {
+        return navNodes;
+      }
+      var currentRouteId = getCurrentRouteId();
+
+      // If no route ID, return empty
+      if (!currentRouteId) {
+        return [];
+      }
+
+      // Find the path to the current page
+      var breadcrumbPath = _findPathToNode(navNodes, currentRouteId);
+
+      // Return the path if found, otherwise return empty
+      return breadcrumbPath.length > 0 ? breadcrumbPath : [];
+    }, [navNodes]);
+    return __jsx(WrappedComponent, (0, _extends2["default"])({}, props, {
+      ref: ref,
+      navNodes: filteredNavNodes,
+      resetNavNodes: resetNodes,
+      handleNavigation: handleNavigation
+    }));
+  });
+  NavigationWrappedComponent.displayName = "withDatasetAwareNavigation(".concat(WrappedComponent.displayName || WrappedComponent.name || "Component", ")");
+  return NavigationWrappedComponent;
+};
+var _default = exports["default"] = withDatasetAwareNavigation;

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,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.accordionExpansionHandler = exports.BaseAppInitialState = void 0;
+exports.importModule = importModule;
+exports.tabSelectionHandler = exports.mergeVariablesAndActions = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _appstore = _interopRequireDefault(require("../core/appstore"));
+var _util = require("../core/util");
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+var _navigationSlice = require("../store/slices/navigationSlice");
+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; }
+var mergeVariablesAndActions = exports.mergeVariablesAndActions = function mergeVariablesAndActions(pageVariables) {
+  var appVars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    Variables: {},
+    Actions: {}
+  };
+  return {
+    Variables: _objectSpread(_objectSpread({}, appVars.Variables), pageVariables.Variables),
+    Actions: _objectSpread(_objectSpread({}, appVars.Actions), pageVariables.Actions)
+  };
+};
+var BaseAppInitialState = exports.BaseAppInitialState = {
+  activePageName: "",
+  lastActivePage: "",
+  Variables: {},
+  Actions: {},
+  isAppReady: false,
+  getDependency: _appstore["default"].getDependency,
+  getCurrentMonth: _util.getCurrentMonth,
+  notification: null,
+  Common: {},
+  onPageReady: function onPageReady() {},
+  reload: _util.reload
+};
+function importModule(moduleName) {
+  if (moduleName === "moment") {
+    var locale = (0, _util.getTimezone)();
+    var guessedTz = locale || _momentTimezone["default"].tz && typeof _momentTimezone["default"].tz.guess === "function" && _momentTimezone["default"].tz.guess() || typeof Intl !== "undefined" && Intl.DateTimeFormat && Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    if (_momentTimezone["default"].tz && typeof _momentTimezone["default"].tz.setDefault === "function") {
+      _momentTimezone["default"].tz.setDefault(guessedTz);
+    }
+    return _momentTimezone["default"];
+  }
+}
+var accordionExpansionHandler = exports.accordionExpansionHandler = function accordionExpansionHandler(pageProxyRef, pendingAccordionExpansion, dispatch) {
+  setTimeout(function () {
+    try {
+      var _pageProxyRef$current;
+      if ((_pageProxyRef$current = pageProxyRef.current) !== null && _pageProxyRef$current !== void 0 && (_pageProxyRef$current = _pageProxyRef$current.Widgets) !== null && _pageProxyRef$current !== void 0 && (_pageProxyRef$current = _pageProxyRef$current[pendingAccordionExpansion]) !== null && _pageProxyRef$current !== void 0 && _pageProxyRef$current.expand) {
+        pageProxyRef.current.Widgets[pendingAccordionExpansion].expand();
+      } else {
+        console.warn("Accordion widget not found: ".concat(pendingAccordionExpansion));
+      }
+    } catch (error) {
+      console.warn("Unable to expand accordion: ".concat(pendingAccordionExpansion), error);
+    } finally {
+      dispatch((0, _navigationSlice.clearPendingAccordionExpansion)());
+    }
+  }, 0);
+};
+var tabSelectionHandler = exports.tabSelectionHandler = function tabSelectionHandler(pageProxyRef, tabNameToSelect, dispatch) {
+  setTimeout(function () {
+    try {
+      var _pageProxyRef$current2;
+      if ((_pageProxyRef$current2 = pageProxyRef.current) !== null && _pageProxyRef$current2 !== void 0 && (_pageProxyRef$current2 = _pageProxyRef$current2.Widgets) !== null && _pageProxyRef$current2 !== void 0 && (_pageProxyRef$current2 = _pageProxyRef$current2[tabNameToSelect]) !== null && _pageProxyRef$current2 !== void 0 && _pageProxyRef$current2.select) {
+        pageProxyRef.current.Widgets[tabNameToSelect].select();
+      } else {
+        console.warn("Tab widget not found: ".concat(tabNameToSelect));
+      }
+    } catch (error) {
+      console.warn("Unable to select tab: ".concat(tabNameToSelect), error);
+    } finally {
+      dispatch((0, _navigationSlice.clearPendingTabSelection)());
+    }
+  }, 0);
+};