@wavemaker/react-runtime 11.14.1-16.6404

package/higherOrder/helper.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseAppInitialState = void 0;
+exports.importModule = importModule;
+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"));
+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") {
+    return _momentTimezone["default"];
+  }
+}

package/higherOrder/props.js

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

package/higherOrder/withBaseWrapper.js

@@ -0,0 +1,183 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withBaseWrapper = exports["default"] = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = _interopRequireWildcard(require("react"));
+var _isEqual = _interopRequireDefault(require("lodash-es/isEqual"));
+var _useDeviceVisibility2 = require("@wavemaker/react-runtime/hooks/useDeviceVisibility");
+var _WidgetProvider = require("@wavemaker/react-runtime/context/WidgetProvider");
+var _styleUtils = require("@wavemaker/react-runtime/utils/style-utils");
+var _scriptRegistry = require("@wavemaker/react-runtime/core/script-registry");
+var _excluded = ["show", "name", "deferload"];
+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 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 withBaseWrapper = exports.withBaseWrapper = function withBaseWrapper(WrappedComponent) {
+  var WithBaseComponent = function WithBaseComponent(props) {
+    var _pageContext$Widgets, _mergedProps$show, _mergedProps$show2;
+    var _props$show = props.show,
+      show = _props$show === void 0 ? true : _props$show,
+      name = props.name,
+      _props$deferload = props.deferload,
+      deferload = _props$deferload === void 0 ? true : _props$deferload,
+      rest = (0, _objectWithoutProperties2["default"])(props, _excluded);
+
+    // All hooks must be called before any early returns
+    var _useDeviceVisibility = (0, _useDeviceVisibility2.useDeviceVisibility)(props.showindevices || ["all"]),
+      isHidden = _useDeviceVisibility.isHidden;
+    var _usePageContext = (0, _WidgetProvider.usePageContext)(),
+      pageContext = _usePageContext.pageContext,
+      updateWidgetState = _usePageContext.updateWidgetState,
+      cleanup = _usePageContext.cleanup;
+
+    // Extract widget-id from component props
+    var componentWidgetId = (0, _react.useMemo)(function () {
+      return props === null || props === void 0 ? void 0 : props["data-widget-id"];
+    }, [props === null || props === void 0 ? void 0 : props["data-widget-id"]]);
+    var widgetFromContext = name ? pageContext === null || pageContext === void 0 || (_pageContext$Widgets = pageContext.Widgets) === null || _pageContext$Widgets === void 0 ? void 0 : _pageContext$Widgets[name] : undefined;
+
+    // Register widget in context (last wins - second component should win)
+    (0, _react.useEffect)(function () {
+      if (name && (props === null || props === void 0 ? void 0 : props.iswidget) !== "false" && pageContext !== null && pageContext !== void 0 && pageContext.Widgets) {
+        // Create registry entry with widget-id
+        var registryEntry = _objectSpread(_objectSpread({}, props), {}, {
+          "data-widget-id": componentWidgetId || undefined // Ensure widget-id is stored
+        });
+
+        // Last component with same name overwrites previous (LAST WINS)
+        pageContext.Widgets[name] = registryEntry;
+      }
+    }, [name, pageContext === null || pageContext === void 0 ? void 0 : pageContext.Widgets, componentWidgetId, props]);
+
+    // Compute merged props in a memoized way
+    var mergedProps = (0, _react.useMemo)(function () {
+      var _widget$datavalue;
+      if (!name || !(pageContext !== null && pageContext !== void 0 && pageContext.Widgets) || (props === null || props === void 0 ? void 0 : props.iswidget) === "false") {
+        return props;
+      }
+      var widget = widgetFromContext || {};
+
+      // Extract widget-id from context widget
+      var contextWidgetId = widget === null || widget === void 0 ? void 0 : widget["data-widget-id"];
+
+      // FIRST WINS: Only merge if this component's widget-id matches the context
+      // OR if no widget-id filtering is needed (backward compatibility)
+      var shouldMergeFromContext = !componentWidgetId || !contextWidgetId || componentWidgetId === contextWidgetId;
+      var mergedState = _objectSpread({}, props);
+      var datavalue = (_widget$datavalue = widget.datavalue) !== null && _widget$datavalue !== void 0 ? _widget$datavalue : props.datavalue;
+      if (shouldMergeFromContext && (0, _scriptRegistry.isWidgetOverridden)(name, componentWidgetId)) {
+        // Apply widget-id specific overridden properties from the registry
+        var widgetOverrides = (0, _scriptRegistry.getWidgetOverrides)(name, componentWidgetId);
+        Object.keys(widgetOverrides).forEach(function (key) {
+          mergedState[key] = widgetOverrides[key];
+        });
+
+        // Then handle other widget properties that are not overridden
+        Object.keys(widget).forEach(function (key) {
+          if (!(0, _scriptRegistry.isPropOverridden)(name, key, componentWidgetId)) {
+            mergedState[key] = props[key];
+          }
+        });
+      } else if (shouldMergeFromContext) {
+        // For regular widgets (no widget-id or matching widget-id), merge with component props taking precedence
+        mergedState = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, widget), props), WrappedComponent.displayName === "WmFormField" && !props.value ? {
+          value: datavalue
+        } : {}), {}, {
+          datavalue: datavalue
+        });
+      } else {
+        // Widget-id mismatch: component stays independent with only its own props
+        mergedState = _objectSpread(_objectSpread(_objectSpread({}, props), WrappedComponent.displayName === "WmFormField" && !props.value ? {
+          value: datavalue
+        } : {}), {}, {
+          datavalue: datavalue
+        });
+      }
+      return mergedState;
+    }, [props, widgetFromContext, componentWidgetId]);
+    var syncWithContext = (0, _react.useCallback)(function () {
+      if (name && pageContext !== null && pageContext !== void 0 && pageContext.Widgets && (props === null || props === void 0 ? void 0 : props.iswidget) !== "false" && !(props !== null && props !== void 0 && props.formfield)) {
+        var currentWidgetState = pageContext.Widgets[name] || {};
+
+        // Extract widget-id from context
+        var contextWidgetId = currentWidgetState === null || currentWidgetState === void 0 ? void 0 : currentWidgetState["data-widget-id"];
+
+        // Only sync if widget-ids match OR no widget-id filtering needed
+        var shouldSync = !componentWidgetId || !contextWidgetId || componentWidgetId === contextWidgetId;
+        if (shouldSync) {
+          // Skip comparing listener property
+          var stateForComparison = _objectSpread({}, currentWidgetState);
+          var propsForComparison = _objectSpread({}, mergedProps);
+          delete stateForComparison.listener;
+          delete propsForComparison.listener;
+          if (!(0, _isEqual["default"])(stateForComparison, propsForComparison)) {
+            updateWidgetState(name, mergedProps);
+          }
+        }
+      }
+    }, [pageContext === null || pageContext === void 0 ? void 0 : pageContext.Widgets, mergedProps, props, componentWidgetId]);
+    (0, _react.useEffect)(function () {
+      syncWithContext();
+    }, [syncWithContext]);
+    var computedStyles = (0, _react.useMemo)(function () {
+      // Ensure conditionalstyle is a valid CSS object or undefined
+      var conditionalStyleObj = (0, _typeof2["default"])(props.conditionalstyle) === "object" && props.conditionalstyle !== null ? (0, _styleUtils.sanitizeStyleObject)(props.conditionalstyle) : {};
+      var baseStyles = (0, _styleUtils.sanitizeStyleObject)(props.styles);
+      return _objectSpread(_objectSpread({}, baseStyles), conditionalStyleObj);
+    }, [props.styles, props.conditionalstyle]);
+    var computedClassName = (0, _react.useMemo)(function () {
+      return [props.className, props.conditionalclass, props.animation && "animated ".concat(props.animation)].filter(Boolean).join(" ");
+    }, [props.className, props.conditionalclass, props.animation]);
+
+    // Early returns after all hooks
+    if (isHidden) return null;
+
+    // Optimized deferload and show logic
+    var isDeferLoad = deferload === true;
+    var showValue = (mergedProps === null || mergedProps === void 0 || (_mergedProps$show = mergedProps.show) === null || _mergedProps$show === void 0 ? void 0 : _mergedProps$show.toString()) !== "false";
+
+    // Implement exact logic from requirements:
+    // show = false, deferload = undefined/false → render initial, not UI (hidden=true)
+    // show = false, deferload = true → don't render at all
+    // show = true, deferload = true → render in both
+    // show = true, deferload = false/undefined → render in UI
+
+    if (!showValue && isDeferLoad) {
+      // Case: show = false, deferload = true → don't render at all
+      return null;
+    }
+
+    // Case: show = false, deferload = false/undefined → render with hidden=true
+    var shouldHide = !showValue && !isDeferLoad;
+    var updateon = (props === null || props === void 0 ? void 0 : props.updateon) === "default" ? "keypress" : props === null || props === void 0 ? void 0 : props.updateon;
+    return __jsx(WrappedComponent, (0, _extends2["default"])({}, rest, mergedProps, updateon && {
+      updateon: updateon
+    }, shouldHide && {
+      hidden: true
+    }, deferload !== undefined && {
+      deferload: deferload.toString()
+    }, {
+      show: mergedProps === null || mergedProps === void 0 || (_mergedProps$show2 = mergedProps.show) === null || _mergedProps$show2 === void 0 ? void 0 : _mergedProps$show2.toString(),
+      name: name,
+      className: computedClassName,
+      styles: computedStyles
+    }, (props === null || props === void 0 ? void 0 : props.dataset) && {
+      dataset: props === null || props === void 0 ? void 0 : props.dataset
+    }));
+  };
+  WithBaseComponent.displayName = "WithBase(".concat(WrappedComponent.displayName || WrappedComponent.name || "Component", ")");
+  return /*#__PURE__*/_react["default"].memo(WithBaseComponent, function (prevProps, nextProps) {
+    return prevProps === nextProps;
+  });
+};
+var _default = exports["default"] = withBaseWrapper;

package/hooks/useAccess.js

@@ -0,0 +1,308 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAccess = exports.preloadAccess = exports["default"] = exports.clearAccessCache = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _react = require("react");
+var _store = require("@wavemaker/react-runtime/store");
+var _authSlice = require("../store/slices/authSlice");
+// Global cache for access results to prevent duplicate checks
+var accessCache = new Map();
+var pendingChecks = new Map();
+var useAccess = exports.useAccess = function useAccess(options) {
+  var componentName = options.componentName,
+    type = options.type,
+    _options$enabled = options.enabled,
+    enabled = _options$enabled === void 0 ? true : _options$enabled;
+  var dispatch = (0, _store.useAppDispatch)();
+
+  // Get security config from store
+  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;
+  });
+
+  // Create a unique key for this component
+  var cacheKey = "".concat(type, "_").concat(componentName);
+
+  // Local state for this component
+  var _useState = (0, _react.useState)(function () {
+      var _cached$hasAccess, _cached$loading, _cached$error;
+      // Check if we already have cached result
+      var cached = accessCache.get(cacheKey);
+
+      // If security is disabled, default to access granted
+      var defaultAccess = !isSecurityEnabled ? true : false;
+      return {
+        hasAccess: (_cached$hasAccess = cached === null || cached === void 0 ? void 0 : cached.hasAccess) !== null && _cached$hasAccess !== void 0 ? _cached$hasAccess : defaultAccess,
+        loading: (_cached$loading = cached === null || cached === void 0 ? void 0 : cached.loading) !== null && _cached$loading !== void 0 ? _cached$loading : isSecurityEnabled ? true : false,
+        error: (_cached$error = cached === null || cached === void 0 ? void 0 : cached.error) !== null && _cached$error !== void 0 ? _cached$error : null
+      };
+    }),
+    localState = _useState[0],
+    setLocalState = _useState[1];
+  var mountedRef = (0, _react.useRef)(true);
+  var hasCheckedRef = (0, _react.useRef)(false);
+
+  // Memoized access check function
+  var checkComponentAccess = (0, _react.useCallback)(/*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var checkPromise, result;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (isSecurityEnabled) {
+            _context.next = 2;
+            break;
+          }
+          return _context.abrupt("return", true);
+        case 2:
+          if (enabled) {
+            _context.next = 4;
+            break;
+          }
+          return _context.abrupt("return", true);
+        case 4:
+          if (!pendingChecks.has(cacheKey)) {
+            _context.next = 6;
+            break;
+          }
+          return _context.abrupt("return", pendingChecks.get(cacheKey));
+        case 6:
+          // Create new access check promise
+          checkPromise = dispatch((0, _authSlice.checkAccess)({
+            name: componentName,
+            type: type
+          })).unwrap(); // Store the pending promise
+          pendingChecks.set(cacheKey, checkPromise);
+          _context.prev = 8;
+          _context.next = 11;
+          return checkPromise;
+        case 11:
+          result = _context.sent;
+          return _context.abrupt("return", result);
+        case 15:
+          _context.prev = 15;
+          _context.t0 = _context["catch"](8);
+          return _context.abrupt("return", false);
+        case 18:
+          _context.prev = 18;
+          // Remove from pending checks
+          pendingChecks["delete"](cacheKey);
+          return _context.finish(18);
+        case 21:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[8, 15, 18, 21]]);
+  })), [dispatch, componentName, type, isSecurityEnabled, enabled, cacheKey]);
+
+  // Effect to perform access check
+  (0, _react.useEffect)(function () {
+    // Don't check if component is unmounted
+    if (!mountedRef.current) return;
+
+    // Don't check multiple times
+    if (hasCheckedRef.current) return;
+
+    // Check if we already have valid cached result
+    var cached = accessCache.get(cacheKey);
+    if (cached && !cached.loading) {
+      setLocalState(cached);
+      hasCheckedRef.current = true;
+      return;
+    }
+
+    // Start access check
+    var performCheck = /*#__PURE__*/function () {
+      var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var loadingState, hasAccess, resultState, errorState;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (mountedRef.current) {
+                _context2.next = 2;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 2:
+              // Update cache and local state to loading
+              loadingState = {
+                hasAccess: false,
+                loading: true,
+                error: null
+              };
+              accessCache.set(cacheKey, loadingState);
+              setLocalState(loadingState);
+              _context2.prev = 5;
+              _context2.next = 8;
+              return checkComponentAccess();
+            case 8:
+              hasAccess = _context2.sent;
+              if (mountedRef.current) {
+                _context2.next = 11;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 11:
+              // Update cache and local state with result
+              resultState = {
+                hasAccess: hasAccess,
+                loading: false,
+                error: null
+              };
+              accessCache.set(cacheKey, resultState);
+              setLocalState(resultState);
+              hasCheckedRef.current = true;
+              _context2.next = 25;
+              break;
+            case 17:
+              _context2.prev = 17;
+              _context2.t0 = _context2["catch"](5);
+              if (mountedRef.current) {
+                _context2.next = 21;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 21:
+              // Update cache and local state with error
+              errorState = {
+                hasAccess: false,
+                loading: false,
+                error: _context2.t0
+              };
+              accessCache.set(cacheKey, errorState);
+              setLocalState(errorState);
+              hasCheckedRef.current = true;
+            case 25:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, null, [[5, 17]]);
+      }));
+      return function performCheck() {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    performCheck();
+  }, [checkComponentAccess, cacheKey]);
+
+  // Cleanup on unmount
+  (0, _react.useEffect)(function () {
+    return function () {
+      mountedRef.current = false;
+      // Optionally clear cache entry on unmount to free memory
+      // accessCache.delete(cacheKey);
+      // pendingChecks.delete(cacheKey);
+    };
+  }, [cacheKey]);
+
+  // Retry function for manual retry
+  var retry = (0, _react.useCallback)(function () {
+    hasCheckedRef.current = false;
+    accessCache["delete"](cacheKey);
+    pendingChecks["delete"](cacheKey);
+
+    // Trigger re-check
+    var performCheck = /*#__PURE__*/function () {
+      var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var loadingState, hasAccess, resultState, errorState;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              loadingState = {
+                hasAccess: false,
+                loading: true,
+                error: null
+              };
+              accessCache.set(cacheKey, loadingState);
+              setLocalState(loadingState);
+              _context3.prev = 3;
+              _context3.next = 6;
+              return checkComponentAccess();
+            case 6:
+              hasAccess = _context3.sent;
+              resultState = {
+                hasAccess: hasAccess,
+                loading: false,
+                error: null
+              };
+              accessCache.set(cacheKey, resultState);
+              setLocalState(resultState);
+              hasCheckedRef.current = true;
+              _context3.next = 19;
+              break;
+            case 13:
+              _context3.prev = 13;
+              _context3.t0 = _context3["catch"](3);
+              errorState = {
+                hasAccess: false,
+                loading: false,
+                error: _context3.t0
+              };
+              accessCache.set(cacheKey, errorState);
+              setLocalState(errorState);
+              hasCheckedRef.current = true;
+            case 19:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, null, [[3, 13]]);
+      }));
+      return function performCheck() {
+        return _ref3.apply(this, arguments);
+      };
+    }();
+    performCheck();
+  }, [checkComponentAccess, cacheKey]);
+  return {
+    hasAccess: localState.hasAccess,
+    loading: localState.loading,
+    error: localState.error,
+    retry: retry,
+    // Expose cache key for debugging
+    cacheKey: cacheKey
+  };
+};
+
+// Utility function to clear all access cache (useful for logout)
+var clearAccessCache = exports.clearAccessCache = function clearAccessCache() {
+  accessCache.clear();
+  pendingChecks.clear();
+};
+
+// Utility function to preload access for multiple components
+var preloadAccess = exports.preloadAccess = /*#__PURE__*/function () {
+  var _ref4 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(components, dispatch) {
+    var promises;
+    return _regenerator["default"].wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          promises = components.map(function (_ref5) {
+            var _accessCache$get;
+            var name = _ref5.name,
+              type = _ref5.type;
+            var cacheKey = "".concat(type, "_").concat(name);
+            if (!accessCache.has(cacheKey)) {
+              return dispatch((0, _authSlice.checkAccess)({
+                name: name,
+                type: type
+              })).unwrap();
+            }
+            return Promise.resolve((_accessCache$get = accessCache.get(cacheKey)) === null || _accessCache$get === void 0 ? void 0 : _accessCache$get.hasAccess);
+          });
+          return _context4.abrupt("return", Promise.allSettled(promises));
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return function preloadAccess(_x, _x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+var _default = exports["default"] = useAccess;

package/hooks/useAppConfig.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAppConfig = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _store = require("../store");
+var _appConfigSlice = require("@wavemaker/react-runtime/store/slices/appConfigSlice");
+var useAppConfig = exports.useAppConfig = function useAppConfig() {
+  var dispatch = (0, _store.useAppDispatch)();
+  var getServiceDefinitionsData = /*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(baseURL) {
+      return _regenerator["default"].wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (baseURL) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return", Promise.resolve({}));
+          case 2:
+            _context.next = 4;
+            return dispatch((0, _appConfigSlice.getServiceDefinitions)(baseURL)).unwrap();
+          case 4:
+            return _context.abrupt("return", _context.sent);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function getServiceDefinitionsData(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  return {
+    getServiceDefinitionsData: getServiceDefinitionsData
+  };
+};