@wavemaker/react-runtime 11.14.1-16.6404

package/higherOrder/BasePage.js

@@ -0,0 +1,715 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withPageContext = exports["default"] = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireWildcard(require("react"));
+var _navigation = require("next/navigation");
+var _isEqual = _interopRequireDefault(require("lodash-es/isEqual"));
+var _cloneDeep = _interopRequireDefault(require("lodash-es/cloneDeep"));
+var _merge = _interopRequireDefault(require("lodash-es/merge"));
+var _WidgetProvider = require("@wavemaker/react-runtime/context/WidgetProvider");
+var _spinner = require("@wavemaker/react-runtime/components/basic/spinner");
+var _appVariablesStore = require("@wavemaker/react-runtime/core/appVariablesStore");
+var _store = require("@wavemaker/react-runtime/store");
+var _AppContext = require("@wavemaker/react-runtime/context/AppContext");
+var _useAccess2 = _interopRequireDefault(require("@wavemaker/react-runtime/hooks/useAccess"));
+var _authSlice = require("@wavemaker/react-runtime/store/slices/authSlice");
+var _types = require("@wavemaker/react-runtime/types");
+var _proxyService = require("@wavemaker/react-runtime/core/proxy-service");
+var _navigationMiddleware = require("@wavemaker/react-runtime/store/middleware/navigationMiddleware");
+var _helper = require("@wavemaker/react-runtime/higherOrder/helper");
+var _toast = require("@wavemaker/react-runtime/actions/toast.service");
+var _appstore = _interopRequireDefault(require("@wavemaker/react-runtime/core/appstore"));
+var _scriptRegistry = require("@wavemaker/react-runtime/core/script-registry");
+var _formatters = _interopRequireDefault(require("../core/formatters"));
+var _AppContext2 = require("../context/AppContext");
+var _utils = require("../core/util/utils");
+var _widgetCleanupUtil = require("../utils/widget-cleanup-util");
+var _pageParamsUtil = require("../utils/page-params-util");
+var _constants = require("../core/constants");
+var _AppSpinnerProvider = require("../context/AppSpinnerProvider");
+var _lodash = require("lodash");
+var _events = require("../core/constants/events");
+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" != _typeof(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 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; }
+// Add global declaration for wm property
+
+var withPageContext = exports.withPageContext = function withPageContext(WrappedComponent, addPageScript, getVariables, componentInfo, prefabInfo) {
+  var PageContextComponent = function PageContextComponent(props) {
+    var _info$appConfig;
+    var dispatch = (0, _store.useAppDispatch)();
+    var _useAppSpinner = (0, _AppSpinnerProvider.useAppSpinner)(),
+      show = _useAppSpinner.show,
+      hide = _useAppSpinner.hide;
+    var i18n = (0, _store.useAppSelector)(function (state) {
+      return state.i18n;
+    });
+    var info = (0, _store.useAppSelector)(function (state) {
+      return state.info;
+    });
+    var pageParams = (0, _navigation.useSearchParams)();
+    // Get app context if available (when used within BaseApp)
+    var appContext = (0, _AppContext.useAppContext)();
+    var appProxy = (0, _AppContext2.useAppProxy)();
+
+    // Use optimized access hook instead of useAccess
+    var _useAccess = (0, _useAccess2["default"])({
+        componentName: (componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentName) || "Main",
+        type: (componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType) || "PAGE"
+      }),
+      hasAccess = _useAccess.hasAccess,
+      accessLoading = _useAccess.loading,
+      accessError = _useAccess.error;
+
+    // Get security status for debugging
+    var isSecurityEnabled = (0, _store.useAppSelector)(function (state) {
+      var _state$auth$securityC;
+      return (_state$auth$securityC = state.auth.securityConfig) === null || _state$auth$securityC === void 0 ? void 0 : _state$auth$securityC.isSecurityEnabled;
+    });
+    var securityConfig = (0, _store.useAppSelector)(function (state) {
+      return state.auth.securityConfig;
+    });
+    var isAuthenticated = (0, _store.useAppSelector)(function (state) {
+      var _state$auth$loggedInU;
+      return (_state$auth$loggedInU = state.auth.loggedInUser) === null || _state$auth$loggedInU === void 0 ? void 0 : _state$auth$loggedInU.isAuthenticated;
+    });
+    var loggedInUser = (0, _store.useAppSelector)(function (state) {
+      return state.auth.loggedInUser;
+    });
+    var appConfig = (0, _store.useAppSelector)(function (state) {
+      return state.info.appConfig;
+    });
+
+    // Initialization state management
+    var _useState = (0, _react.useState)(false),
+      isInitialized = _useState[0],
+      setIsInitialized = _useState[1];
+    var _useState2 = (0, _react.useState)(false),
+      startupComplete = _useState2[0],
+      setStartupComplete = _useState2[1];
+    var redirectHandledRef = (0, _react.useRef)(false);
+
+    // Refs for managing component lifecycle
+    var subscriptionsRef = (0, _react.useRef)([]);
+    var pendingStartupOpsRef = (0, _react.useRef)(new Set());
+    var startUpVariableLoadedRef = (0, _react.useRef)(false);
+    var pageProxyRef = (0, _react.useRef)(null);
+    var isInitializingRef = (0, _react.useRef)(false);
+    var isMountedRef = (0, _react.useRef)(true);
+    var startupInvokedRef = (0, _react.useRef)(false);
+    var usedFallbackAppVarsRef = (0, _react.useRef)(false);
+    var appVarSubscriptionsDoneRef = (0, _react.useRef)(false);
+    var subscribedVariableNamesRef = (0, _react.useRef)(new Set());
+    var cleanupUtilRef = (0, _react.useRef)(null);
+
+    // Initial page context state
+    var _useState3 = (0, _react.useState)(_objectSpread(_objectSpread(_objectSpread(_objectSpread({
+        Widgets: {},
+        Variables: {},
+        Actions: {},
+        onReady: function onReady() {},
+        serviceDefinitions: (0, _cloneDeep["default"])((prefabInfo === null || prefabInfo === void 0 ? void 0 : prefabInfo.serviceDefs) || (appContext === null || appContext === void 0 ? void 0 : appContext.serviceDefinitions) || {}),
+        pageParams: {},
+        baseUrl: (prefabInfo === null || prefabInfo === void 0 ? void 0 : prefabInfo.baseUrl) || (info === null || info === void 0 || (_info$appConfig = info.appConfig) === null || _info$appConfig === void 0 ? void 0 : _info$appConfig.url) || "",
+        appConfig: appContext === null || appContext === void 0 ? void 0 : appContext.appConfig,
+        notification: {},
+        toaster: _toast.toastService,
+        onContentReady: onContentReady,
+        onChange: updateWidgetState,
+        cleanup: cleanup,
+        App: {},
+        eval: appContext === null || appContext === void 0 ? void 0 : appContext.eval,
+        appLocale: componentInfo.appLocale || i18n.appLocale || {}
+      }, prefabInfo), props), componentInfo), {}, {
+        executeStartup: executeStartup,
+        formatters: _formatters["default"]
+      })),
+      pageContext = _useState3[0],
+      setPageContext = _useState3[1];
+
+    // Enhanced initial app config that inherits from app context if available
+    var initialAppConfig = (0, _react.useMemo)(function () {
+      return appContext;
+    }, [appContext]);
+
+    // Handle redirect to login if authentication is required
+    (0, _react.useEffect)(function () {
+      var _appConfig$pages;
+      if ((componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType) !== "PAGE" || redirectHandledRef.current || accessLoading || !isSecurityEnabled) {
+        return;
+      }
+
+      // Check if page requires authentication
+      var pageConfig = appConfig === null || appConfig === void 0 || (_appConfig$pages = appConfig.pages) === null || _appConfig$pages === void 0 ? void 0 : _appConfig$pages.find(function (p) {
+        var _componentInfo$compon;
+        return p.name.toLowerCase() === (componentInfo === null || componentInfo === void 0 || (_componentInfo$compon = componentInfo.componentName) === null || _componentInfo$compon === void 0 ? void 0 : _componentInfo$compon.toLowerCase());
+      });
+
+      // Redirect to login if page requires authentication and user is not authenticated
+      var requiresAuth = (pageConfig === null || pageConfig === void 0 ? void 0 : pageConfig.permission) === "Authenticated" || (pageConfig === null || pageConfig === void 0 ? void 0 : pageConfig.permission) === "Role";
+      if (requiresAuth && !isAuthenticated) {
+        redirectHandledRef.current = true;
+        dispatch((0, _authSlice.redirectToLogin)({
+          redirectTo: componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentName,
+          securityConfig: securityConfig
+        }));
+      }
+    }, [accessLoading, isSecurityEnabled, isAuthenticated, appConfig, componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType, componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentName, dispatch, securityConfig]);
+
+    // Handle redirect from login page to landing page if already authenticated
+    (0, _react.useEffect)(function () {
+      var _securityConfig$login;
+      if ((componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType) !== "PAGE" || !isSecurityEnabled || !isAuthenticated || accessLoading) {
+        return;
+      }
+      var loginPage = securityConfig === null || securityConfig === void 0 || (_securityConfig$login = securityConfig.loginConfig) === null || _securityConfig$login === void 0 ? void 0 : _securityConfig$login.pageName;
+      var landingPage = loggedInUser === null || loggedInUser === void 0 ? void 0 : loggedInUser.landingPage;
+      if (!loginPage || !landingPage) {
+        return;
+      }
+
+      // Extract the last segment of the pathname (the page name)
+      var currentPageName = componentInfo.componentName;
+      var isOnLoginPage = currentPageName === loginPage;
+
+      // If authenticated user is on login page, redirect to landing page
+      if (isOnLoginPage) {
+        var router = (0, _navigationMiddleware.getRouterInstance)();
+        if (router) {
+          console.log("BasePage: Redirecting authenticated user from login to landing page", landingPage);
+          router.push("/".concat(_constants.ROUTING_BASEPATH, "/").concat(landingPage));
+        }
+      }
+    }, [componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType, isSecurityEnabled, isAuthenticated, accessLoading, securityConfig, loggedInUser === null || loggedInUser === void 0 ? void 0 : loggedInUser.landingPage]);
+
+    // Check if we should proceed with initialization
+    var shouldInitialize = (0, _react.useMemo)(function () {
+      // Wait for app to be ready (if app context exists)
+      if (appContext && !appContext.isAppReady) {
+        return false;
+      }
+
+      // Wait for access check to complete
+      if (accessLoading) {
+        return false;
+      }
+
+      // Don't initialize if no access
+      if (!hasAccess && isSecurityEnabled) {
+        if (isAuthenticated) {
+          var _pageContext$appLocal;
+          appContext === null || appContext === void 0 || appContext.notifyApp((pageContext === null || pageContext === void 0 || (_pageContext$appLocal = pageContext.appLocale) === null || _pageContext$appLocal === void 0 || (_pageContext$appLocal = _pageContext$appLocal.LABELS) === null || _pageContext$appLocal === void 0 ? void 0 : _pageContext$appLocal.ACCESS_DENIED) || "Access Denied", "Error");
+        }
+        return false;
+      }
+      return true;
+    }, [appContext === null || appContext === void 0 ? void 0 : appContext.isAppReady, accessLoading, hasAccess, isSecurityEnabled, isAuthenticated]);
+
+    // Update page context with app variables when app context changes
+    (0, _react.useEffect)(function () {
+      if (!(appContext !== null && appContext !== void 0 && appContext.isAppReady) || !pageProxyRef.current) {
+        return;
+      }
+
+      // Update page context with app variables without triggering re-initialization
+      setPageContext(function (prev) {
+        var updatedVariables = _objectSpread(_objectSpread({}, prev.Variables), appContext.Variables || {});
+        var updatedActions = _objectSpread(_objectSpread({}, prev.Actions), appContext.Actions || {});
+
+        // Update proxy with the same object references
+        pageProxyRef.current.Variables = updatedVariables;
+        pageProxyRef.current.Actions = updatedActions;
+        pageProxyRef.current.App = _objectSpread(_objectSpread({}, pageProxyRef.current.App), {}, {
+          Variables: appContext.Variables || {},
+          Actions: appContext.Actions || {}
+        });
+        return _objectSpread(_objectSpread({}, prev), {}, {
+          Variables: updatedVariables,
+          Actions: updatedActions
+        });
+      });
+    }, [appContext === null || appContext === void 0 ? void 0 : appContext.isAppReady]);
+
+    // Main initialization effect - runs only when conditions are met
+    (0, _react.useEffect)(function () {
+      // Early returns for non-initialization cases
+      if (!shouldInitialize || isInitialized || isInitializingRef.current || !isMountedRef.current) {
+        return;
+      }
+
+      // Set initialization flag
+      isInitializingRef.current = true;
+      var initializeComponent = /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+          var pageProxy, pageVariables, appVariables, APP_VARIABLES, _mergeVariablesAndAct, Variables, Actions, urlParams, newParams, pageName;
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                try {
+                  // Create page proxy
+                  pageProxy = (0, _proxyService.createStateProxy)(pageContext, [], setPageContext);
+                  pageProxyRef.current = pageProxy;
+
+                  // Initialize cleanup utility
+                  if (!cleanupUtilRef.current) {
+                    cleanupUtilRef.current = (0, _widgetCleanupUtil.createWidgetCleanup)({
+                      setPageContext: setPageContext,
+                      proxyRef: pageProxyRef,
+                      debounceDelay: 100
+                    });
+                  }
+
+                  // Initialize variables and actions
+                  pageVariables = getVariables(pageProxy); // Handle app variables based on app context availability
+                  appVariables = {
+                    Variables: {},
+                    Actions: {}
+                  };
+                  if (appContext !== null && appContext !== void 0 && appContext.isAppReady) {
+                    // If app context is available and ready, use app variables directly
+                    appVariables = {
+                      Variables: appContext.Variables || {},
+                      Actions: appContext.Actions || {}
+                    };
+                    usedFallbackAppVarsRef.current = false;
+                  } else {
+                    // Fallback to traditional app variable initialization
+                    // @ts-ignore
+                    APP_VARIABLES = _appstore["default"].get("AppConfig").appVariables;
+                    appVariables = APP_VARIABLES ? (0, _appVariablesStore.getAppVariablesInstance)(pageProxy, APP_VARIABLES) : {
+                      Variables: {},
+                      Actions: {}
+                    };
+                    usedFallbackAppVarsRef.current = true;
+                  }
+                  _mergeVariablesAndAct = (0, _helper.mergeVariablesAndActions)(pageVariables, appVariables), Variables = _mergeVariablesAndAct.Variables, Actions = _mergeVariablesAndAct.Actions; // Compute page params from URL and include partial params when applicable
+                  urlParams = Object.fromEntries(pageParams.entries());
+                  newParams = (0, _pageParamsUtil.computeMergedPageParams)(urlParams, {
+                    componentType: componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType,
+                    props: props
+                  }); // Update proxy with merged variables and actions
+                  pageProxy.Variables = Variables;
+                  pageProxy.Actions = Actions;
+                  pageProxy.pageParams = _objectSpread({}, newParams);
+                  pageProxy.App = _objectSpread(_objectSpread(_objectSpread({}, initialAppConfig), appVariables), {}, {
+                    pageParams: _objectSpread({}, newParams),
+                    selectedLocale: i18n.selectedLocale || "en"
+                  });
+
+                  // Setup variable event handlers
+                  setupVariableSubscriptions(pageVariables.Variables);
+                  if ((componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType) === "PAGE" && appProxy) {
+                    pageName = componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentName;
+                    appProxy.updateActivePage(pageName);
+                  }
+
+                  // Initialize page script
+                  try {
+                    addPageScript(appProxy, pageProxy);
+                  } catch (e) {
+                    if ((0, _utils.isJQueryError)(e)) {
+                      appContext === null || appContext === void 0 || appContext.notifyApp("React App is not supporting this functionality check console for more details", "Error");
+                    }
+                    console.error(e);
+                  }
+
+                  // Setup global wm object for pages
+                  if ((componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType) === "PAGE") {
+                    global.wm = appProxy ? _objectSpread(_objectSpread({}, pageProxy), {}, {
+                      App: appProxy
+                    }) : pageProxy;
+                  }
+
+                  // Mark as initialized
+                  setIsInitialized(true);
+                } catch (error) {
+                  console.error("Error during component initialization:", error);
+                  // Still mark as initialized to prevent hanging
+                  setIsInitialized(true);
+                } finally {
+                  isInitializingRef.current = false;
+                }
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }));
+        return function initializeComponent() {
+          return _ref.apply(this, arguments);
+        };
+      }();
+      initializeComponent();
+
+      // Cleanup function
+      return function () {
+        var _cleanupUtilRef$curre;
+        // Cancel all pending page operations
+        if (pageProxyRef.current) {
+          var _ref2 = getVariables(pageProxyRef.current) || {},
+            _ref2$Variables = _ref2.Variables,
+            Variables = _ref2$Variables === void 0 ? {} : _ref2$Variables,
+            _ref2$Actions = _ref2.Actions,
+            Actions = _ref2$Actions === void 0 ? {} : _ref2$Actions;
+
+          // Cancel page variables
+          Object.values(Variables).forEach(function (variable) {
+            if (variable !== null && variable !== void 0 && variable.cancel && typeof variable.cancel === "function") {
+              try {
+                variable.cancel();
+              } catch (error) {
+                console.warn("Failed to cancel page variable:", error);
+              }
+            }
+          });
+
+          // Cancel page actions
+          Object.values(Actions).forEach(function (action) {
+            if (action !== null && action !== void 0 && action.cancel && typeof action.cancel === "function") {
+              try {
+                action.cancel();
+              } catch (error) {
+                console.warn("Failed to cancel page timer action:", error);
+              }
+            }
+          });
+        }
+
+        // Clear pending startup operations
+        pendingStartupOpsRef.current.clear();
+        (0, _scriptRegistry.clearOverriddenProps)();
+
+        // Unsubscribe from events
+        subscriptionsRef.current.forEach(function (_ref3) {
+          var variable = _ref3.variable,
+            event = _ref3.event,
+            handler = _ref3.handler;
+          if (variable !== null && variable !== void 0 && variable.unsubscribe) {
+            try {
+              variable.unsubscribe(event, handler);
+            } catch (error) {
+              console.warn("Failed to unsubscribe from ".concat(event, ":"), error);
+            }
+          }
+        });
+        subscriptionsRef.current = [];
+
+        // Cancel any pending cleanup operations
+        (_cleanupUtilRef$curre = cleanupUtilRef.current) === null || _cleanupUtilRef$curre === void 0 || _cleanupUtilRef$curre.cancel();
+      };
+    }, [shouldInitialize]); // Only depend on shouldInitialize
+
+    // If initialized with fallback app vars, subscribe to real app vars when app becomes ready
+    (0, _react.useEffect)(function () {
+      if (!(appContext !== null && appContext !== void 0 && appContext.isAppReady) || !pageProxyRef.current || !usedFallbackAppVarsRef.current || appVarSubscriptionsDoneRef.current) {
+        return;
+      }
+      try {
+        var _ref4 = getVariables(pageProxyRef.current) || {
+            Variables: {}
+          },
+          _ref4$Variables = _ref4.Variables,
+          pageVars = _ref4$Variables === void 0 ? {} : _ref4$Variables;
+        var pageVarNames = new Set(Object.keys(pageVars || {}));
+        subscribeAppVariablesIfNeeded(appContext.Variables || {}, pageVarNames);
+        appVarSubscriptionsDoneRef.current = true;
+      } catch (e) {
+        // no-op
+      }
+    }, [appContext === null || appContext === void 0 ? void 0 : appContext.isAppReady]);
+
+    // Prefab state sync
+    (0, _react.useEffect)(function () {
+      if (prefabInfo && (componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType) === "PREFAB") {
+        var handlePrefabStateRefresh = function handlePrefabStateRefresh(data) {
+          Object.keys(data).forEach(function (key) {
+            var onPropertyChange = pageProxyRef.current.onPropertyChange;
+            if (onPropertyChange) {
+              onPropertyChange(data[key].key, data[key].newValue, data[key].oldValue);
+              // pageProxyRef.current[data[key].key] = data[key].newValue;
+              pageContext.Widgets[data[key].key] = data[key].newValue;
+            }
+          });
+        };
+        _events.EVENTEMITTER_METHODS.PREFAB_STATE_SYNC_ON(handlePrefabStateRefresh);
+        return function () {
+          _events.EVENTEMITTER_METHODS.PREFAB_STATE_SYNC_OFF(handlePrefabStateRefresh);
+        };
+      }
+    }, [prefabInfo, componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentType]);
+
+    // Setup variable subscriptions
+    var setupVariableSubscriptions = function setupVariableSubscriptions(variables) {
+      var handleVariableEvent = function handleVariableEvent(variableName, event, variable) {
+        // not required because while unmounting page,variables invocation get cancelled and state update will not happen
+
+        var updateState = variable;
+        updateState.loading = event === _types.VariableEvents.BEFORE_INVOKE;
+        updateState.error = event === _types.VariableEvents.ERROR ? variable : null;
+        if ((0, _lodash.get)(variable, "spinnerContext") === "page") {
+          if (updateState.loading) {
+            var message = (0, _lodash.get)(variable, "spinnerMessage");
+            show(message);
+          } else {
+            hide();
+          }
+        }
+        setPageContext(function (prev) {
+          return _objectSpread(_objectSpread({}, prev), {}, {
+            Variables: _objectSpread(_objectSpread({}, prev.Variables), {}, (0, _defineProperty2["default"])({}, variableName, updateState))
+          });
+        });
+        if (event === _types.VariableEvents.AFTER_INVOKE) {
+          pendingStartupOpsRef.current["delete"](variableName);
+        }
+      };
+
+      // Set up subscriptions (avoid duplicates by name)
+      Object.entries(variables).forEach(function (_ref5) {
+        var _ref6 = (0, _slicedToArray2["default"])(_ref5, 2),
+          name = _ref6[0],
+          variable = _ref6[1];
+        if (subscribedVariableNamesRef.current.has(name)) {
+          return;
+        }
+        Object.values(_types.VariableEvents).forEach(function (event) {
+          var handler = function handler() {
+            return handleVariableEvent(name, event, variable);
+          };
+          if (variable && typeof variable.subscribe === "function") {
+            variable.subscribe(event, handler);
+            subscriptionsRef.current.push({
+              variable: variable,
+              event: event,
+              handler: handler
+            });
+          }
+        });
+        subscribedVariableNamesRef.current.add(name);
+      });
+    };
+
+    // Subscribe to app-level variables that are not shadowed by page variables
+    var subscribeAppVariablesIfNeeded = function subscribeAppVariablesIfNeeded(appVars, pageVarNames) {
+      var appVarsOnly = {};
+      Object.entries(appVars || {}).forEach(function (_ref7) {
+        var _ref8 = (0, _slicedToArray2["default"])(_ref7, 2),
+          name = _ref8[0],
+          variable = _ref8[1];
+        if (!pageVarNames.has(name) && !subscribedVariableNamesRef.current.has(name)) {
+          appVarsOnly[name] = variable;
+        }
+      });
+      if (Object.keys(appVarsOnly).length) {
+        setupVariableSubscriptions(appVarsOnly);
+      }
+    };
+
+    // Execute startup operations
+    var executeStartupOperations = /*#__PURE__*/function () {
+      var _ref9 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(Variables, Actions) {
+        var _ref0, _ref0$startUpActions, startUpActions, _ref0$startUpVariable, startUpVariables, variablePromises;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _ref0 = componentInfo || {}, _ref0$startUpActions = _ref0.startUpActions, startUpActions = _ref0$startUpActions === void 0 ? [] : _ref0$startUpActions, _ref0$startUpVariable = _ref0.startUpVariables, startUpVariables = _ref0$startUpVariable === void 0 ? [] : _ref0$startUpVariable; // Track startup operations
+              startUpVariables.forEach(function (name) {
+                return pendingStartupOpsRef.current.add(name);
+              });
+              startUpActions.forEach(function (name) {
+                return pendingStartupOpsRef.current.add(name);
+              });
+
+              // If no startup operations, mark as complete immediately
+              if (!(startUpActions.length === 0 && startUpVariables.length === 0)) {
+                _context2.next = 6;
+                break;
+              }
+              setTimeout(function () {
+                if (isMountedRef.current) {
+                  setStartupComplete(true);
+                }
+              }, 100);
+              return _context2.abrupt("return");
+            case 6:
+              _context2.prev = 6;
+              // Execute startup actions
+              startUpActions.forEach(function (actionName) {
+                var _Actions$actionName;
+                if ((_Actions$actionName = Actions[actionName]) !== null && _Actions$actionName !== void 0 && _Actions$actionName.invoke) {
+                  Actions[actionName].invoke();
+                }
+                pendingStartupOpsRef.current["delete"](String(actionName));
+              });
+
+              // Execute startup variables
+              variablePromises = startUpVariables.map(function (varName) {
+                var _Variables$varName;
+                if ((_Variables$varName = Variables[varName]) !== null && _Variables$varName !== void 0 && _Variables$varName.invoke) {
+                  return Variables[varName].invoke()["catch"](function (error) {
+                    console.log("Error invoking ".concat(varName, ":"), error);
+                    return null;
+                  });
+                }
+                return Promise.resolve();
+              });
+              _context2.next = 11;
+              return Promise.allSettled(variablePromises);
+            case 11:
+              startUpVariableLoadedRef.current = true;
+              pendingStartupOpsRef.current.clear();
+              if (isMountedRef.current) {
+                setStartupComplete(true);
+              }
+              _context2.next = 20;
+              break;
+            case 16:
+              _context2.prev = 16;
+              _context2.t0 = _context2["catch"](6);
+              console.error("Error during startup operations:", _context2.t0);
+              if (isMountedRef.current) {
+                setStartupComplete(true); // Set complete even on error to prevent hanging
+              }
+            case 20:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, null, [[6, 16]]);
+      }));
+      return function executeStartupOperations(_x, _x2) {
+        return _ref9.apply(this, arguments);
+      };
+    }();
+
+    // Cleanup function for unmounting widgets
+    function cleanup(name) {
+      var _cleanupUtilRef$curre2;
+      (_cleanupUtilRef$curre2 = cleanupUtilRef.current) === null || _cleanupUtilRef$curre2 === void 0 || _cleanupUtilRef$curre2.cleanup(name);
+    }
+
+    // Widget state update function
+    function updateWidgetState(widgetName, newProps) {
+      if (!widgetName || !newProps || Object.keys(newProps).length === 0) return;
+      if ((0, _isEqual["default"])(pageContext.Widgets[widgetName], newProps)) return;
+      setPageContext(function (prev) {
+        return _objectSpread(_objectSpread({}, prev), {}, {
+          Widgets: _objectSpread(_objectSpread({}, prev.Widgets), {}, (0, _defineProperty2["default"])({}, widgetName, _objectSpread(_objectSpread({}, prev.Widgets[widgetName]), newProps)))
+        });
+      });
+      Object.keys(newProps).forEach(function (key) {
+        var _pageContext$Widgets$;
+        if (!(0, _isEqual["default"])((_pageContext$Widgets$ = pageContext.Widgets[widgetName]) === null || _pageContext$Widgets$ === void 0 ? void 0 : _pageContext$Widgets$[key], newProps === null || newProps === void 0 ? void 0 : newProps[key]) && (newProps === null || newProps === void 0 ? void 0 : newProps[key]) !== undefined) {
+          pageProxyRef.current.Widgets[widgetName][key] = newProps[key];
+        }
+      });
+    }
+
+    // Content ready callback
+    function onContentReady() {
+      if (appContext !== null && appContext !== void 0 && appContext.onPageReady && pageContext.type === "PAGE") {
+        appContext.onPageReady(pageContext.componentName, pageProxyRef.current, undefined);
+      }
+      if (pageContext.onReady) {
+        try {
+          pageContext.onReady();
+        } catch (e) {
+          if ((0, _utils.isJQueryError)(e)) {
+            appContext === null || appContext === void 0 || appContext.notifyApp("React App is not supporting this functionality check console for more details", "Error");
+          }
+          console.error(e);
+        }
+      }
+    }
+    function executeStartup() {
+      return _executeStartup.apply(this, arguments);
+    } // Update pageContext.appLocale when i18n.appLocale changes
+    function _executeStartup() {
+      _executeStartup = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              appContext === null || appContext === void 0 || appContext.executeStartAppOperations();
+              _context3.next = 3;
+              return executeStartupOperations(pageContext.Variables, pageContext.Actions);
+            case 3:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      return _executeStartup.apply(this, arguments);
+    }
+    (0, _react.useEffect)(function () {
+      var newAppLocale = (0, _merge["default"])({}, i18n.appLocale || {}, (prefabInfo === null || prefabInfo === void 0 ? void 0 : prefabInfo.appLocale) || {});
+      if (!(0, _isEqual["default"])(pageContext.appLocale, newAppLocale)) {
+        setPageContext(function (prev) {
+          return _objectSpread(_objectSpread({}, prev), {}, {
+            appLocale: newAppLocale
+          });
+        });
+      }
+    }, [i18n.appLocale]);
+
+    // Call onContentReady when startup operations are complete
+    (0, _react.useEffect)(function () {
+      if (isMountedRef.current) {
+        onContentReady();
+      }
+    }, []);
+
+    // Cleanup on unmount
+    (0, _react.useEffect)(function () {
+      return function () {
+        isMountedRef.current = false;
+      };
+    }, []);
+
+    // Handle access denied case
+    if (!accessLoading && !hasAccess && !(componentInfo !== null && componentInfo !== void 0 && componentInfo.isPartOfPrefab)) {
+      return null;
+    }
+
+    // Handle access error case
+    if (accessError && !accessLoading) {
+      console.error("Access check failed for ".concat(componentInfo === null || componentInfo === void 0 ? void 0 : componentInfo.componentName, ":"), accessError);
+      return null;
+    }
+
+    // Show loading spinner while checking access or app is not ready
+    if (accessLoading || appContext && !appContext.isAppReady || !isInitialized) {
+      return __jsx(_spinner.WmSpinner, {
+        name: "page",
+        caption: "",
+        listener: {}
+      });
+    }
+    if (pageContext.autoUpdateVariables) {
+      var pageVariables = pageContext.Variables;
+      componentInfo.autoUpdateVariables.forEach(function (value) {
+        var _pageVariables$value, _pageVariables$value2;
+        ((_pageVariables$value = pageVariables[value]) === null || _pageVariables$value === void 0 ? void 0 : _pageVariables$value.invokeOnParamChange) && ((_pageVariables$value2 = pageVariables[value]) === null || _pageVariables$value2 === void 0 ? void 0 : _pageVariables$value2.invokeOnParamChange());
+      });
+    }
+
+    // Render the component
+    return __jsx(_WidgetProvider.WidgetProvider, {
+      value: {
+        value: pageContext,
+        proxy: pageProxyRef.current
+      }
+    }, __jsx(WrappedComponent, props));
+  };
+  PageContextComponent.displayName = "WithPageContext(".concat(WrappedComponent.displayName || WrappedComponent.name || "Component", ")");
+  return PageContextComponent;
+};
+var _default = exports["default"] = withPageContext;