@refinedev/core 4.47.2 → 4.48.0

package/src/contexts/auditLog/IAuditLogContext.ts

@@ -1,31 +1,31 @@
 import { BaseKey, MetaDataQuery } from "../../interfaces";
 
 export type LogParams = {
-    resource: string;
-    action: string;
-    data?: any;
-    author?: {
-        name?: string;
-        [key: string]: any;
-    };
-    previousData?: any;
-    meta: Record<number | string, any>;
+  resource: string;
+  action: string;
+  data?: any;
+  author?: {
+    name?: string;
+    [key: string]: any;
+  };
+  previousData?: any;
+  meta: Record<number | string, any>;
 };
 
 export type IAuditLogContext = {
-    create?: (params: LogParams) => Promise<any>;
-    get?: (params: {
-        resource: string;
-        action?: string;
-        meta?: Record<number | string, any>;
-        author?: Record<number | string, any>;
-        metaData?: MetaDataQuery;
-    }) => Promise<any>;
-    update?: (params: {
-        id: BaseKey;
-        name: string;
-        [key: string]: any;
-    }) => Promise<any>;
+  create?: (params: LogParams) => Promise<any>;
+  get?: (params: {
+    resource: string;
+    action?: string;
+    meta?: Record<number | string, any>;
+    author?: Record<number | string, any>;
+    metaData?: MetaDataQuery;
+  }) => Promise<any>;
+  update?: (params: {
+    id: BaseKey;
+    name: string;
+    [key: string]: any;
+  }) => Promise<any>;
 };
 
 export type AuditLogProvider = Required<IAuditLogContext>;

package/src/contexts/auditLog/index.tsx

@@ -5,13 +5,13 @@ import { IAuditLogContext } from "./IAuditLogContext";
 export const AuditLogContext = React.createContext<IAuditLogContext>({});
 
 export const AuditLogContextProvider: React.FC<
-    IAuditLogContext & {
-        children: React.ReactNode;
-    }
+  IAuditLogContext & {
+    children: React.ReactNode;
+  }
 > = ({ create, get, update, children }) => {
-    return (
-        <AuditLogContext.Provider value={{ create, get, update }}>
-            {children}
-        </AuditLogContext.Provider>
-    );
+  return (
+    <AuditLogContext.Provider value={{ create, get, update }}>
+      {children}
+    </AuditLogContext.Provider>
+  );
 };

package/src/contexts/auth/IAuthContext.ts

@@ -8,20 +8,20 @@ export type TUpdatePasswordData = void | false | string;
  * @deprecated `LegacyAuthProvider` is deprecated with refine@4, use `AuthProvider` instead, however, we still support `LegacyAuthProvider` for backward compatibility.
  */
 export interface LegacyAuthProvider {
-    login: (params: any) => Promise<TLoginData>;
-    register?: (params: any) => Promise<TRegisterData>;
-    forgotPassword?: (params: any) => Promise<TForgotPasswordData>;
-    updatePassword?: (params: any) => Promise<TUpdatePasswordData>;
-    logout: (params: any) => Promise<TLogoutData>;
-    checkAuth: (params?: any) => Promise<any>;
-    checkError: (error: any) => Promise<void>;
-    getPermissions?: (params?: any) => Promise<any>;
-    getUserIdentity?: (params?: any) => Promise<any>;
+  login: (params: any) => Promise<TLoginData>;
+  register?: (params: any) => Promise<TRegisterData>;
+  forgotPassword?: (params: any) => Promise<TForgotPasswordData>;
+  updatePassword?: (params: any) => Promise<TUpdatePasswordData>;
+  logout: (params: any) => Promise<TLogoutData>;
+  checkAuth: (params?: any) => Promise<any>;
+  checkError: (error: any) => Promise<void>;
+  getPermissions?: (params?: Record<string, any>) => Promise<any>;
+  getUserIdentity?: (params?: any) => Promise<any>;
 }
 
 /**
  * @deprecated `IAuthContext` is deprecated with refine@4, use `AuthBindingsContext` instead, however, we still support `IAuthContext` for backward compatibility.
  */
 export interface ILegacyAuthContext extends Partial<LegacyAuthProvider> {
-    isProvided?: boolean;
+  isProvided?: boolean;
 }

package/src/contexts/auth/index.tsx

@@ -12,192 +12,192 @@ export const LegacyAuthContext = React.createContext<ILegacyAuthContext>({});
  * @deprecated `LegacyAuthContextProvider` is deprecated with refine@4, use `AuthBindingsContextProvider` instead, however, we still support `LegacyAuthContextProvider` for backward compatibility.
  */
 export const LegacyAuthContextProvider: React.FC<
-    ILegacyAuthContext & {
-        children?: React.ReactNode;
-    }
+  ILegacyAuthContext & {
+    children?: React.ReactNode;
+  }
 > = ({ children, isProvided, ...authOperations }) => {
-    const { replace } = useNavigation();
-
-    const loginFunc = async (params: any) => {
-        try {
-            const result = await authOperations.login?.(params);
-
-            return result;
-        } catch (error) {
-            return Promise.reject(error);
-        }
-    };
-
-    const registerFunc = async (params: any) => {
-        try {
-            const result = await authOperations.register?.(params);
-
-            return result;
-        } catch (error) {
-            return Promise.reject(error);
-        }
-    };
-
-    const logoutFunc = async (params: any) => {
-        try {
-            const redirectPath = await authOperations.logout?.(params);
-
-            return redirectPath;
-        } catch (error) {
-            return Promise.reject(error);
-        }
-    };
-
-    const checkAuthFunc = async (params: any) => {
-        try {
-            await authOperations.checkAuth?.(params);
-            return Promise.resolve();
-        } catch (error) {
-            if ((error as { redirectPath?: string })?.redirectPath) {
-                replace((error as { redirectPath: string }).redirectPath);
-            }
-
-            return Promise.reject(error);
-        }
-    };
-
-    return (
-        <LegacyAuthContext.Provider
-            value={{
-                ...authOperations,
-                login: loginFunc,
-                logout: logoutFunc,
-                checkAuth: checkAuthFunc,
-                register: registerFunc,
-                isProvided,
-            }}
-        >
-            {children}
-        </LegacyAuthContext.Provider>
-    );
+  const { replace } = useNavigation();
+
+  const loginFunc = async (params: any) => {
+    try {
+      const result = await authOperations.login?.(params);
+
+      return result;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  };
+
+  const registerFunc = async (params: any) => {
+    try {
+      const result = await authOperations.register?.(params);
+
+      return result;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  };
+
+  const logoutFunc = async (params: any) => {
+    try {
+      const redirectPath = await authOperations.logout?.(params);
+
+      return redirectPath;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  };
+
+  const checkAuthFunc = async (params: any) => {
+    try {
+      await authOperations.checkAuth?.(params);
+      return Promise.resolve();
+    } catch (error) {
+      if ((error as { redirectPath?: string })?.redirectPath) {
+        replace((error as { redirectPath: string }).redirectPath);
+      }
+
+      return Promise.reject(error);
+    }
+  };
+
+  return (
+    <LegacyAuthContext.Provider
+      value={{
+        ...authOperations,
+        login: loginFunc,
+        logout: logoutFunc,
+        checkAuth: checkAuthFunc,
+        register: registerFunc,
+        isProvided,
+      }}
+    >
+      {children}
+    </LegacyAuthContext.Provider>
+  );
 };
 
 export const AuthBindingsContext = React.createContext<
-    Partial<IAuthBindingsContext>
+  Partial<IAuthBindingsContext>
 >({});
 
 export const AuthBindingsContextProvider: React.FC<
-    PropsWithChildren<IAuthBindingsContext>
+  PropsWithChildren<IAuthBindingsContext>
 > = ({ children, isProvided, ...authBindings }) => {
-    const handleLogin = async (params: unknown) => {
-        try {
-            const result = await authBindings.login?.(params);
-
-            return result;
-        } catch (error) {
-            console.warn(
-                "Unhandled Error in login: refine always expects a resolved promise.",
-                error,
-            );
-            return Promise.reject(error);
-        }
-    };
-
-    const handleRegister = async (params: unknown) => {
-        try {
-            const result = await authBindings.register?.(params);
-
-            return result;
-        } catch (error) {
-            console.warn(
-                "Unhandled Error in register: refine always expects a resolved promise.",
-                error,
-            );
-            return Promise.reject(error);
-        }
-    };
-
-    const handleLogout = async (params: unknown) => {
-        try {
-            const result = await authBindings.logout?.(params);
-
-            return result;
-        } catch (error) {
-            console.warn(
-                "Unhandled Error in logout: refine always expects a resolved promise.",
-                error,
-            );
-            return Promise.reject(error);
-        }
-    };
-
-    const handleCheck = async (params: unknown) => {
-        try {
-            const result = await authBindings.check?.(params);
-
-            return Promise.resolve(result);
-        } catch (error) {
-            console.warn(
-                "Unhandled Error in check: refine always expects a resolved promise.",
-                error,
-            );
-            return Promise.reject(error);
-        }
-    };
-
-    const handleForgotPassword = async (params: unknown) => {
-        try {
-            const result = await authBindings.forgotPassword?.(params);
-
-            return Promise.resolve(result);
-        } catch (error) {
-            console.warn(
-                "Unhandled Error in forgotPassword: refine always expects a resolved promise.",
-                error,
-            );
-            return Promise.reject(error);
-        }
-    };
-
-    const handleUpdatePassword = async (params: unknown) => {
-        try {
-            const result = await authBindings.updatePassword?.(params);
-            return Promise.resolve(result);
-        } catch (error) {
-            console.warn(
-                "Unhandled Error in updatePassword: refine always expects a resolved promise.",
-                error,
-            );
-            return Promise.reject(error);
-        }
-    };
-
-    return (
-        <AuthBindingsContext.Provider
-            value={{
-                ...authBindings,
-                login: handleLogin as IAuthBindingsContext["login"],
-                logout: handleLogout as IAuthBindingsContext["logout"],
-                check: handleCheck as IAuthBindingsContext["check"],
-                register: handleRegister as IAuthBindingsContext["register"],
-                forgotPassword:
-                    handleForgotPassword as IAuthBindingsContext["forgotPassword"],
-                updatePassword:
-                    handleUpdatePassword as IAuthBindingsContext["updatePassword"],
-                isProvided,
-            }}
-        >
-            {children}
-        </AuthBindingsContext.Provider>
-    );
+  const handleLogin = async (params: unknown) => {
+    try {
+      const result = await authBindings.login?.(params);
+
+      return result;
+    } catch (error) {
+      console.warn(
+        "Unhandled Error in login: refine always expects a resolved promise.",
+        error,
+      );
+      return Promise.reject(error);
+    }
+  };
+
+  const handleRegister = async (params: unknown) => {
+    try {
+      const result = await authBindings.register?.(params);
+
+      return result;
+    } catch (error) {
+      console.warn(
+        "Unhandled Error in register: refine always expects a resolved promise.",
+        error,
+      );
+      return Promise.reject(error);
+    }
+  };
+
+  const handleLogout = async (params: unknown) => {
+    try {
+      const result = await authBindings.logout?.(params);
+
+      return result;
+    } catch (error) {
+      console.warn(
+        "Unhandled Error in logout: refine always expects a resolved promise.",
+        error,
+      );
+      return Promise.reject(error);
+    }
+  };
+
+  const handleCheck = async (params: unknown) => {
+    try {
+      const result = await authBindings.check?.(params);
+
+      return Promise.resolve(result);
+    } catch (error) {
+      console.warn(
+        "Unhandled Error in check: refine always expects a resolved promise.",
+        error,
+      );
+      return Promise.reject(error);
+    }
+  };
+
+  const handleForgotPassword = async (params: unknown) => {
+    try {
+      const result = await authBindings.forgotPassword?.(params);
+
+      return Promise.resolve(result);
+    } catch (error) {
+      console.warn(
+        "Unhandled Error in forgotPassword: refine always expects a resolved promise.",
+        error,
+      );
+      return Promise.reject(error);
+    }
+  };
+
+  const handleUpdatePassword = async (params: unknown) => {
+    try {
+      const result = await authBindings.updatePassword?.(params);
+      return Promise.resolve(result);
+    } catch (error) {
+      console.warn(
+        "Unhandled Error in updatePassword: refine always expects a resolved promise.",
+        error,
+      );
+      return Promise.reject(error);
+    }
+  };
+
+  return (
+    <AuthBindingsContext.Provider
+      value={{
+        ...authBindings,
+        login: handleLogin as IAuthBindingsContext["login"],
+        logout: handleLogout as IAuthBindingsContext["logout"],
+        check: handleCheck as IAuthBindingsContext["check"],
+        register: handleRegister as IAuthBindingsContext["register"],
+        forgotPassword:
+          handleForgotPassword as IAuthBindingsContext["forgotPassword"],
+        updatePassword:
+          handleUpdatePassword as IAuthBindingsContext["updatePassword"],
+        isProvided,
+      }}
+    >
+      {children}
+    </AuthBindingsContext.Provider>
+  );
 };
 
 /**
  * @deprecated `useLegacyAuthContext` is deprecated with refine@4, use `useAuthBindingsContext` instead, however, we still support `useLegacyAuthContext` for backward compatibility.
  */
 export const useLegacyAuthContext = () => {
-    const context = React.useContext(LegacyAuthContext);
+  const context = React.useContext(LegacyAuthContext);
 
-    return context;
+  return context;
 };
 
 export const useAuthBindingsContext = () => {
-    const context = React.useContext(AuthBindingsContext);
+  const context = React.useContext(AuthBindingsContext);
 
-    return context;
+  return context;
 };