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

package/hooks/useAuth.js

@@ -0,0 +1,338 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { useEffect, useState } from "react";
+import { useAppDispatch, useAppSelector } from "../store";
+import {
+  loadSecurityInfo,
+  login,
+  logout,
+  canAccessPage,
+  checkAccess,
+  USER_ROLE,
+  navigateToLandingPage,
+  setPageLoading
+} from "../store/slices/authSlice";
+import includes from "lodash-es/includes";
+import { getServiceDefinitions } from "../store/slices/appConfigSlice";
+const useAuth = () => {
+  const dispatch = useAppDispatch();
+  const { isLoggedIn, loggedInUser, securityConfig, isPageLoading, error } = useAppSelector(
+    (state) => state.auth
+  );
+  const securityEnabled = useAppSelector(
+    (state) => {
+      var _a, _b, _c;
+      return !!((_c = (_b = (_a = state.info) == null ? void 0 : _a.appConfig) == null ? void 0 : _b.appProperties) == null ? void 0 : _c.securityEnabled);
+    }
+  );
+  const handleLogin = async (options) => {
+    try {
+      const loginResponse = await dispatch(login(options)).unwrap();
+      return loginResponse;
+    } catch (error2) {
+      throw error2;
+    }
+  };
+  const handleLogout = async (baseURL) => {
+    try {
+      const logoutResponse = await dispatch(logout({ baseURL })).unwrap();
+      return logoutResponse;
+    } catch (error2) {
+      return error2;
+    }
+  };
+  const checkCanAccessPage = async (pageName) => {
+    const baseUrl = (securityConfig == null ? void 0 : securityConfig.baseUrl) || "";
+    return await dispatch(canAccessPage({ pageName })).unwrap();
+  };
+  const hasAccessToWidget = (widgetRoles) => {
+    if (!(securityConfig == null ? void 0 : securityConfig.isSecurityEnabled)) {
+      return true;
+    }
+    const widgetRolesArr = widgetRoles.split(",");
+    if (includes(widgetRolesArr, USER_ROLE.EVERYONE)) {
+      return true;
+    }
+    if (includes(widgetRolesArr, USER_ROLE.ANONYMOUS) && !(loggedInUser == null ? void 0 : loggedInUser.isAuthenticated)) {
+      return true;
+    }
+    if (includes(widgetRolesArr, USER_ROLE.AUTHENTICATED) && (loggedInUser == null ? void 0 : loggedInUser.isAuthenticated)) {
+      return true;
+    }
+    return !!(loggedInUser == null ? void 0 : loggedInUser.isAuthenticated) && matchRoles(widgetRolesArr, (loggedInUser == null ? void 0 : loggedInUser.roles) || []);
+  };
+  const matchRoles = (widgetRoles, userRoles) => {
+    return widgetRoles.some((role) => includes(userRoles, role));
+  };
+  const getLoggedInUserDetails = async (baseURL) => {
+    if (!securityEnabled) {
+      dispatch(setPageLoading(true));
+      await dispatch(getServiceDefinitions(baseURL)).unwrap();
+      dispatch(setPageLoading(false));
+      return Promise.resolve({});
+    }
+    return await dispatch(loadSecurityInfo(baseURL)).unwrap();
+  };
+  const authNavigateToLandingPage = async (options) => {
+    try {
+      await dispatch(navigateToLandingPage(options)).unwrap();
+      return true;
+    } catch (error2) {
+      return error2 || false;
+    }
+  };
+  return {
+    isLoggedIn,
+    loggedInUser,
+    securityConfig,
+    isPageLoading,
+    error,
+    login: handleLogin,
+    logout: handleLogout,
+    canAccessPage: checkCanAccessPage,
+    hasAccessToWidget,
+    getLoggedInUserDetails,
+    navigateToLandingPage: authNavigateToLandingPage
+  };
+};
+const usePageAccess = (pageName) => {
+  const dispatch = useAppDispatch();
+  const { loggedInUser } = useAppSelector((state2) => state2.auth);
+  const [state, setState] = useState({
+    hasAccess: false,
+    loading: true,
+    currentPage: pageName
+  });
+  const hasAccess = pageName === state.currentPage ? state.hasAccess : false;
+  const loading = pageName !== state.currentPage || state.loading;
+  useEffect(() => {
+    if (pageName !== state.currentPage) {
+      setState((prev) => __spreadProps(__spreadValues({}, prev), {
+        currentPage: pageName,
+        hasAccess: false,
+        loading: true
+      }));
+    }
+    const checkAccess2 = async () => {
+      try {
+        const access = await dispatch(canAccessPage({ pageName })).unwrap();
+        setState((prev) => {
+          if (prev.currentPage !== pageName) return prev;
+          return __spreadProps(__spreadValues({}, prev), {
+            hasAccess: access,
+            loading: false
+          });
+        });
+      } catch (error) {
+        console.error("Error checking page access:", error);
+        setState((prev) => {
+          if (prev.currentPage !== pageName) return prev;
+          return __spreadProps(__spreadValues({}, prev), {
+            hasAccess: false,
+            loading: false
+          });
+        });
+      }
+    };
+    checkAccess2();
+  }, [pageName, loggedInUser, dispatch]);
+  return {
+    hasAccess,
+    loading
+  };
+};
+const useWidgetAccess = (widgetRoles) => {
+  const { hasAccessToWidget } = useAuth();
+  return hasAccessToWidget(widgetRoles);
+};
+const useAccess = (name, type) => {
+  const dispatch = useAppDispatch();
+  const { loggedInUser, securityConfig } = useAppSelector((state2) => state2.auth);
+  const [state, setState] = useState({
+    hasAccess: false,
+    loading: true,
+    currentItem: `${type}-${name}`
+  });
+  const hasAccess = `${type}-${name}` === state.currentItem ? state.hasAccess : false;
+  const loading = `${type}-${name}` !== state.currentItem || state.loading;
+  useEffect(() => {
+    if (!name) {
+      setState((prev) => __spreadProps(__spreadValues({}, prev), {
+        currentItem: `${type}-${name}`,
+        hasAccess: true,
+        // Allow access when no name specified
+        loading: false
+      }));
+      return;
+    }
+    const currentItemKey = `${type}-${name}`;
+    if (currentItemKey !== state.currentItem) {
+      setState((prev) => __spreadProps(__spreadValues({}, prev), {
+        currentItem: currentItemKey,
+        hasAccess: false,
+        loading: true
+      }));
+    }
+    const checkItemAccess = async () => {
+      try {
+        const access = await dispatch(checkAccess({ name, type })).unwrap();
+        setState((prev) => {
+          if (prev.currentItem !== currentItemKey) return prev;
+          return __spreadProps(__spreadValues({}, prev), {
+            hasAccess: access,
+            loading: false
+          });
+        });
+      } catch (error) {
+        console.error(`Error checking ${type.toLowerCase()} access:`, error);
+        setState((prev) => {
+          if (prev.currentItem !== currentItemKey) return prev;
+          return __spreadProps(__spreadValues({}, prev), {
+            hasAccess: false,
+            loading: false
+          });
+        });
+      }
+    };
+    checkItemAccess();
+  }, [name, type, loggedInUser, securityConfig, dispatch]);
+  return {
+    hasAccess,
+    loading
+  };
+};
+const checkAccessSync = (name, type, authState, appConfig) => {
+  var _a, _b, _c;
+  const userRoles = ((_a = authState == null ? void 0 : authState.loggedInUser) == null ? void 0 : _a.roles) || [];
+  const isAuthenticated = ((_b = authState == null ? void 0 : authState.loggedInUser) == null ? void 0 : _b.isAuthenticated) || false;
+  const isSecurityEnabled = (_c = authState == null ? void 0 : authState.securityConfig) == null ? void 0 : _c.isSecurityEnabled;
+  if (!isSecurityEnabled) {
+    return true;
+  }
+  const configs = type === "PAGE" ? (appConfig == null ? void 0 : appConfig.pages) || [] : (appConfig == null ? void 0 : appConfig.partials) || [];
+  const serializableConfigs = configs.map((item) => ({
+    name: item.name,
+    permission: item.permission,
+    allowedRoles: item.allowedRoles,
+    type: item.type
+  }));
+  const config = serializableConfigs.find(
+    (item) => item.name.toLowerCase() === name.toLowerCase()
+  );
+  if (!config) {
+    return false;
+  }
+  switch (config.permission) {
+    case "PermitAll":
+      return true;
+    case "Authenticated":
+      return isAuthenticated;
+    case "Role":
+      if (!isAuthenticated) {
+        return false;
+      }
+      const allowedRoles = config.allowedRoles || [];
+      if (allowedRoles.length === 0) {
+        return false;
+      }
+      return allowedRoles.some((role) => userRoles.includes(role));
+    default:
+      return false;
+  }
+};
+const useLogin = () => {
+  const dispatch = useAppDispatch();
+  const { isLoggedIn, error } = useAppSelector((state) => state.auth);
+  const [loading, setLoading] = useState(false);
+  const [loginError, setLoginError] = useState(null);
+  const handleLogin = async (options) => {
+    setLoading(true);
+    setLoginError(null);
+    try {
+      await dispatch(login(options)).unwrap();
+      return true;
+    } catch (err) {
+      setLoginError(err instanceof Error ? err.message : "Login failed");
+      return false;
+    } finally {
+      setLoading(false);
+    }
+  };
+  return {
+    loading,
+    error: loginError || error,
+    isLoggedIn,
+    handleLogin,
+    clearError: () => setLoginError(null)
+  };
+};
+const useLogout = () => {
+  const dispatch = useAppDispatch();
+  const [loading, setLoading] = useState(false);
+  const [logoutError, setLogoutError] = useState(null);
+  const handleLogout = async (baseURL) => {
+    setLoading(true);
+    setLogoutError(null);
+    try {
+      await dispatch(logout({ baseURL })).unwrap();
+      return true;
+    } catch (err) {
+      setLogoutError(err instanceof Error ? err.message : "Logout failed");
+      return false;
+    } finally {
+      setLoading(false);
+    }
+  };
+  return {
+    loading,
+    error: logoutError,
+    handleLogout,
+    clearError: () => setLogoutError(null)
+  };
+};
+const useCurrentUser = () => {
+  const { loggedInUser, isLoggedIn } = useAppSelector((state) => state.auth);
+  return {
+    user: loggedInUser,
+    isLoggedIn,
+    hasRole: (role) => {
+      if (!loggedInUser || !loggedInUser.roles) return false;
+      return loggedInUser.roles.includes(role);
+    },
+    hasAnyRole: (roles) => {
+      if (!loggedInUser || !loggedInUser.roles) return false;
+      return roles.some((role) => loggedInUser.roles.includes(role));
+    },
+    hasAllRoles: (roles) => {
+      if (!loggedInUser || !loggedInUser.roles) return false;
+      return roles.every((role) => loggedInUser.roles.includes(role));
+    }
+  };
+};
+export {
+  checkAccessSync,
+  useAccess,
+  useAuth,
+  useCurrentUser,
+  useLogin,
+  useLogout,
+  usePageAccess,
+  useWidgetAccess
+};

package/hooks/useDataSourceSubscription.d.ts

@@ -0,0 +1,15 @@
+import { StorageType } from "@wavemaker-ai/react-runtime/utils/state-persistance";
+interface DataSourceSubscriptionOptions {
+    datasource: any;
+    statehandler: StorageType;
+    name: string;
+    onPageRestored?: (page: number) => void;
+    widgetType?: "list" | "table";
+}
+/**
+ * Subscribes to variable events so persisted list/table state is applied on first invoke.
+ * - check-state-persistence-options: before HTTP (Crud + ServiceVariable)
+ * - toggle-variable-state: Angular handleLoading fallback if check-state did not run yet
+ */
+export declare const useDataSourceSubscription: ({ datasource, statehandler, name, onPageRestored, widgetType, }: DataSourceSubscriptionOptions) => void;
+export {};

package/hooks/useDataSourceSubscription.js

@@ -0,0 +1,115 @@
+import { useRef, useMemo } from "react";
+import { getListState } from "../components/data/list/utils/list-helpers";
+import {
+  convertFilterArrayToObject,
+  getTableState
+} from "../components/data/table/utils/table-helpers";
+import { DataSource } from "../components/data/types";
+import EventNotifier from "../core/event-notifier";
+import { wmSetDependency } from "@wavemaker-ai/variables";
+let sharedEventNotifier = null;
+const getSharedEventNotifier = () => {
+  if (!sharedEventNotifier) {
+    sharedEventNotifier = new EventNotifier();
+    sharedEventNotifier.notify = sharedEventNotifier.notifyApp.bind(sharedEventNotifier);
+    wmSetDependency("appManager", sharedEventNotifier);
+  }
+  return sharedEventNotifier;
+};
+const applyPersistedState = (invokeOptions, ctx) => {
+  var _a, _b;
+  const { datasource, statehandler, name, onPageRestored, widgetType, pageLoadRef } = ctx;
+  if (!pageLoadRef.current || !statehandler || statehandler.toLowerCase() === "none") {
+    return;
+  }
+  pageLoadRef.current = false;
+  const widgetState = widgetType === "table" ? getTableState(name, statehandler) : getListState(name, statehandler);
+  if (!widgetState) {
+    return;
+  }
+  if (widgetState.pagination !== void 0 && invokeOptions.page === void 0) {
+    invokeOptions.page = widgetState.pagination;
+  }
+  if (widgetState.pagesize) {
+    datasource.maxResults = widgetState.pagesize;
+    if (invokeOptions.size === void 0) {
+      invokeOptions.size = widgetState.pagesize;
+    }
+    if (invokeOptions.pagesize === void 0) {
+      invokeOptions.pagesize = widgetState.pagesize;
+    }
+  }
+  if (widgetType === "table") {
+    const tableState = widgetState;
+    if ((_a = tableState.search) == null ? void 0 : _a.length) {
+      invokeOptions.filterFields = convertFilterArrayToObject(tableState.search);
+    }
+    if ((_b = tableState.sort) == null ? void 0 : _b.field) {
+      invokeOptions.orderBy = `${tableState.sort.field} ${tableState.sort.direction}`;
+    }
+  }
+  if (widgetState.pagination !== void 0) {
+    onPageRestored == null ? void 0 : onPageRestored(widgetState.pagination);
+  }
+};
+const matchesDatasource = (eventVariable, datasource) => {
+  return (eventVariable == null ? void 0 : eventVariable.execute(DataSource.Operation.GET_UNIQUE_IDENTIFIER)) === (datasource == null ? void 0 : datasource.execute(DataSource.Operation.GET_UNIQUE_IDENTIFIER));
+};
+const useDataSourceSubscription = ({
+  datasource,
+  statehandler,
+  name,
+  onPageRestored,
+  widgetType = "list"
+}) => {
+  const pageLoadRef = useRef(true);
+  const unsubscribeRefs = useRef([]);
+  const eventNotifier = getSharedEventNotifier();
+  useMemo(() => {
+    if (!datasource || !eventNotifier) {
+      return;
+    }
+    if (unsubscribeRefs.current.length > 0) {
+      unsubscribeRefs.current.forEach((unsub) => unsub());
+      unsubscribeRefs.current = [];
+    }
+    const ctx = {
+      datasource,
+      statehandler,
+      name,
+      onPageRestored,
+      widgetType,
+      pageLoadRef
+    };
+    const onCheckState = (data) => {
+      if (!(data == null ? void 0 : data.variable) || !(data == null ? void 0 : data.options) || !matchesDatasource(data.variable, datasource)) {
+        return;
+      }
+      applyPersistedState(data.options, ctx);
+    };
+    const onToggleState = (data) => {
+      if (!(data == null ? void 0 : data.variable) || !data.active || !matchesDatasource(data.variable, datasource)) {
+        return;
+      }
+      if (!pageLoadRef.current) {
+        return;
+      }
+      const invokeOptions = data.options || {};
+      applyPersistedState(invokeOptions, ctx);
+      if (data.options !== invokeOptions) {
+        data.options = invokeOptions;
+      }
+    };
+    unsubscribeRefs.current = [
+      eventNotifier.subscribe("check-state-persistence-options", onCheckState),
+      eventNotifier.subscribe("toggle-variable-state", onToggleState)
+    ];
+    return () => {
+      unsubscribeRefs.current.forEach((unsub) => unsub());
+      unsubscribeRefs.current = [];
+    };
+  }, [datasource, statehandler, name, onPageRestored, widgetType, eventNotifier]);
+};
+export {
+  useDataSourceSubscription
+};

package/hooks/useDebounce.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A hook that returns a debounced version of the provided callback function.
+ * The callback will only be executed after the specified delay has passed since the last invocation.
+ *
+ * @param callback - The function to debounce
+ * @param delay - The delay in milliseconds
+ * @returns A debounced version of the callback function with a cancel method
+ */
+export declare const useDebounceCallback: <T extends (...args: any[]) => void>(callback: T, delay: number) => T & {
+    cancel: () => void;
+};
+/**
+ * A simpler debounce utility function that can be used outside of React components
+ *
+ * @param func - The function to debounce
+ * @param delay - The delay in milliseconds
+ * @returns A debounced version of the function with a cancel method
+ */
+export declare const debounce: <T extends (...args: any[]) => void>(func: T, delay: number) => T & {
+    cancel: () => void;
+};

package/hooks/useDebounce.js

@@ -0,0 +1,48 @@
+import { useRef, useCallback } from "react";
+const useDebounceCallback = (callback, delay) => {
+  const timeoutRef = useRef(null);
+  const debouncedCallback = useCallback(
+    ((...args) => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        callback(...args);
+        timeoutRef.current = null;
+      }, delay);
+    }),
+    [callback, delay]
+  );
+  const cancel = useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  debouncedCallback.cancel = cancel;
+  return debouncedCallback;
+};
+const debounce = (func, delay) => {
+  let timeoutId = null;
+  const debouncedFunction = ((...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      func(...args);
+      timeoutId = null;
+    }, delay);
+  });
+  const cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  debouncedFunction.cancel = cancel;
+  return debouncedFunction;
+};
+export {
+  debounce,
+  useDebounceCallback
+};

package/hooks/useDeviceVisibility.d.ts

@@ -0,0 +1,4 @@
+export declare const useDeviceVisibility: (devices?: ("xs" | "sm" | "md" | "lg" | "all")[]) => {
+    isHidden: boolean;
+    windowSize: number;
+};

package/hooks/useDeviceVisibility.js

@@ -0,0 +1,40 @@
+"use client";
+import { useState, useEffect } from "react";
+const useDeviceVisibility = (devices) => {
+  const [windowSize, setWindowSize] = useState(
+    typeof window !== "undefined" ? window.innerWidth : void 0
+  );
+  const checkIsHidden = () => {
+    if (!windowSize) return false;
+    if (!devices || devices.length === 0 || devices.includes("all")) {
+      return false;
+    }
+    if (windowSize <= 767) {
+      return !devices.includes("xs");
+    }
+    if (windowSize >= 768 && windowSize <= 991) {
+      return !devices.includes("sm");
+    }
+    if (windowSize >= 992 && windowSize <= 1199) {
+      return !devices.includes("md");
+    }
+    if (windowSize >= 1200) {
+      return !devices.includes("lg");
+    }
+    return false;
+  };
+  useEffect(() => {
+    const handleResize = () => {
+      setWindowSize(window.innerWidth);
+    };
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
+  return {
+    isHidden: checkIsHidden(),
+    windowSize
+  };
+};
+export {
+  useDeviceVisibility
+};

package/hooks/useHttp.d.ts

@@ -0,0 +1,58 @@
+import { AxiosInstance } from "axios";
+import { ReactNode } from "react";
+import { HttpClientService } from "@wavemaker-ai/variables";
+interface HttpContextType extends HttpClientService {
+    axiosInstance: AxiosInstance;
+}
+interface HttpProviderProps {
+    children: ReactNode;
+    baseURL?: string;
+}
+declare class ModernHttpService implements HttpClientService {
+    private axiosInstance;
+    private _context;
+    localeObject: any;
+    constructor(baseURL?: string);
+    /**
+     * Set the current context (page/component context)
+     * @param context - The context object to store
+     */
+    setContext(context: any): void;
+    /**
+     * Get the currently stored context
+     * @returns The stored context object
+     */
+    getContext(): any;
+    getAppManager(): any;
+    private handleSessionFailure;
+    private setupInterceptors;
+    send(options: any, variable: any): Promise<any>;
+    sendCall(requestParams: any, variable: any): Promise<any>;
+    setLocale(locale: string): void;
+    getLocale(): any;
+    cancel(variable: any): void;
+    /**
+     * Handle file download operations with proper filename extraction and blob processing
+     * @param response - Axios response object
+     * @param options - Request options
+     * @param variable - Variable configuration
+     * @returns Modified response object with download success information
+     */
+    private handleFileDownload;
+    uploadFile(url: string, data: any, variable: any, options?: any): Promise<any>;
+}
+export declare const HttpProvider: ({ children, baseURL }: HttpProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useHttp: () => HttpContextType;
+export declare const getHttpService: () => ModernHttpService;
+export declare const httpService: {
+    readonly instance: ModernHttpService;
+    send: (options: any, variable: any) => Promise<any>;
+    sendCall: (requestParams: any, variable: any) => Promise<any>;
+    cancel: (variable: any) => void;
+    uploadFile: (url: string, data: any, variable: any, options?: any) => Promise<any>;
+    setLocale: (locale: string) => void;
+    getLocale: () => any;
+    setContext: (context: any) => void;
+    getContext: () => any;
+};
+export default httpService;