@refinedev/core 4.47.2 → 4.48.0

package/src/hooks/notification/useCancelNotification/index.tsx

@@ -4,13 +4,13 @@ import { UndoableQueueContext } from "@contexts/undoableQueue";
 import { IUndoableQueue, IUndoableQueueContext } from "../../../interfaces";
 
 export type UseCancelNotificationType = () => {
-    notifications: IUndoableQueue[];
-    notificationDispatch: React.Dispatch<any>;
+  notifications: IUndoableQueue[];
+  notificationDispatch: React.Dispatch<any>;
 };
 
 export const useCancelNotification: UseCancelNotificationType = () => {
-    const { notifications, notificationDispatch } =
-        useContext<IUndoableQueueContext>(UndoableQueueContext);
+  const { notifications, notificationDispatch } =
+    useContext<IUndoableQueueContext>(UndoableQueueContext);
 
-    return { notifications, notificationDispatch };
+  return { notifications, notificationDispatch };
 };

package/src/hooks/notification/useHandleNotification/index.ts

@@ -4,23 +4,23 @@ import { OpenNotificationParams } from "../../../interfaces";
 import { useNotification } from "@hooks";
 
 export const useHandleNotification = (): typeof handleNotification => {
-    const { open } = useNotification();
+  const { open } = useNotification();
 
-    const handleNotification = useCallback(
-        (
-            notification: OpenNotificationParams | false | undefined,
-            fallbackNotification?: OpenNotificationParams,
-        ) => {
-            if (notification !== false) {
-                if (notification) {
-                    open?.(notification);
-                } else if (fallbackNotification) {
-                    open?.(fallbackNotification);
-                }
-            }
-        },
-        [],
-    );
+  const handleNotification = useCallback(
+    (
+      notification: OpenNotificationParams | false | undefined,
+      fallbackNotification?: OpenNotificationParams,
+    ) => {
+      if (notification !== false) {
+        if (notification) {
+          open?.(notification);
+        } else if (fallbackNotification) {
+          open?.(fallbackNotification);
+        }
+      }
+    },
+    [],
+  );
 
-    return handleNotification;
+  return handleNotification;
 };

package/src/hooks/notification/useNotification/index.ts

@@ -4,7 +4,7 @@ import { NotificationContext } from "@contexts/notification";
 import { INotificationContext } from "../../../interfaces";
 
 export const useNotification = (): INotificationContext => {
-    const { open, close } = useContext(NotificationContext);
+  const { open, close } = useContext(NotificationContext);
 
-    return { open, close };
+  return { open, close };
 };

package/src/hooks/redirection/index.ts

@@ -1,56 +1,55 @@
 import { useCallback } from "react";
 
 import {
-    BaseKey,
-    IResourceItem,
-    MetaDataQuery,
-    RedirectAction,
+  BaseKey,
+  IResourceItem,
+  MetaDataQuery,
+  RedirectAction,
 } from "../../interfaces";
 import { useNavigation } from "@hooks";
 
 export type UseRedirectionAfterSubmissionType = () => (options: {
-    redirect: RedirectAction;
-    resource?: IResourceItem;
-    id?: BaseKey;
-    meta?: MetaDataQuery;
+  redirect: RedirectAction;
+  resource?: IResourceItem;
+  id?: BaseKey;
+  meta?: MetaDataQuery;
 }) => void;
 
 export const useRedirectionAfterSubmission: UseRedirectionAfterSubmissionType =
-    () => {
-        const { show, edit, list, create } = useNavigation();
-
-        const handleSubmitWithRedirect = useCallback(
-            ({
-                redirect,
-                resource,
-                id,
-                meta = {},
-            }: {
-                redirect: RedirectAction;
-                resource?: IResourceItem;
-                id?: BaseKey;
-                meta?: MetaDataQuery;
-            }) => {
-                if (redirect && resource) {
-                    if (!!resource.show && redirect === "show" && id) {
-                        return show(resource, id, undefined, meta);
-                    }
-
-                    if (!!resource.edit && redirect === "edit" && id) {
-                        return edit(resource, id, undefined, meta);
-                    }
-
-                    if (!!resource.create && redirect === "create") {
-                        return create(resource, undefined, meta);
-                    }
-
-                    return list(resource, "push", meta);
-                } else {
-                    return;
-                }
-            },
-            [],
-        );
-
-        return handleSubmitWithRedirect;
-    };
+  () => {
+    const { show, edit, list, create } = useNavigation();
+
+    const handleSubmitWithRedirect = useCallback(
+      ({
+        redirect,
+        resource,
+        id,
+        meta = {},
+      }: {
+        redirect: RedirectAction;
+        resource?: IResourceItem;
+        id?: BaseKey;
+        meta?: MetaDataQuery;
+      }) => {
+        if (redirect && resource) {
+          if (!!resource.show && redirect === "show" && id) {
+            return show(resource, id, undefined, meta);
+          }
+
+          if (!!resource.edit && redirect === "edit" && id) {
+            return edit(resource, id, undefined, meta);
+          }
+
+          if (!!resource.create && redirect === "create") {
+            return create(resource, undefined, meta);
+          }
+
+          return list(resource, "push", meta);
+        }
+        return;
+      },
+      [],
+    );
+
+    return handleSubmitWithRedirect;
+  };

package/src/hooks/refine/useMutationMode.ts

@@ -4,8 +4,8 @@ import { RefineContext } from "@contexts/refine";
 import { IRefineContextOptions } from "../../interfaces";
 
 type UseMutationModeType = () => {
-    mutationMode: IRefineContextOptions["mutationMode"];
-    undoableTimeout: IRefineContextOptions["undoableTimeout"];
+  mutationMode: IRefineContextOptions["mutationMode"];
+  undoableTimeout: IRefineContextOptions["undoableTimeout"];
 };
 
 /**
@@ -16,7 +16,7 @@ type UseMutationModeType = () => {
  * @see {@link https://refine.dev/docs/guides-and-concepts/mutation-mode} for more details.
  */
 export const useMutationMode: UseMutationModeType = () => {
-    const { mutationMode, undoableTimeout } = useContext(RefineContext);
+  const { mutationMode, undoableTimeout } = useContext(RefineContext);
 
-    return { mutationMode, undoableTimeout };
+  return { mutationMode, undoableTimeout };
 };

package/src/hooks/refine/useRefineContext.ts

@@ -3,41 +3,41 @@ import { useContext } from "react";
 import { RefineContext } from "@contexts/refine";
 
 export const useRefineContext = () => {
-    const {
-        Footer,
-        Header,
-        Layout,
-        OffLayoutArea,
-        Sider,
-        Title,
-        hasDashboard,
-        mutationMode,
-        syncWithLocation,
-        undoableTimeout,
-        warnWhenUnsavedChanges,
-        DashboardPage,
-        LoginPage,
-        catchAll,
-        options,
-        __initialized,
-    } = useContext(RefineContext);
+  const {
+    Footer,
+    Header,
+    Layout,
+    OffLayoutArea,
+    Sider,
+    Title,
+    hasDashboard,
+    mutationMode,
+    syncWithLocation,
+    undoableTimeout,
+    warnWhenUnsavedChanges,
+    DashboardPage,
+    LoginPage,
+    catchAll,
+    options,
+    __initialized,
+  } = useContext(RefineContext);
 
-    return {
-        __initialized,
-        Footer,
-        Header,
-        Layout,
-        OffLayoutArea,
-        Sider,
-        Title,
-        hasDashboard,
-        mutationMode,
-        syncWithLocation,
-        undoableTimeout,
-        warnWhenUnsavedChanges,
-        DashboardPage,
-        LoginPage,
-        catchAll,
-        options,
-    };
+  return {
+    __initialized,
+    Footer,
+    Header,
+    Layout,
+    OffLayoutArea,
+    Sider,
+    Title,
+    hasDashboard,
+    mutationMode,
+    syncWithLocation,
+    undoableTimeout,
+    warnWhenUnsavedChanges,
+    DashboardPage,
+    LoginPage,
+    catchAll,
+    options,
+  };
 };

package/src/hooks/refine/useSyncWithLocation.ts

@@ -4,7 +4,7 @@ import { RefineContext } from "@contexts/refine";
 import { IRefineContextOptions } from "../../interfaces";
 
 type UseSyncWithLocationType = () => {
-    syncWithLocation: IRefineContextOptions["syncWithLocation"];
+  syncWithLocation: IRefineContextOptions["syncWithLocation"];
 };
 
 /**
@@ -14,7 +14,7 @@ type UseSyncWithLocationType = () => {
  * @see {@link https://refine.dev/docs/api-reference/core/components/refine-config/#syncwithlocation} for more details.
  */
 export const useSyncWithLocation: UseSyncWithLocationType = () => {
-    const { syncWithLocation } = useContext(RefineContext);
+  const { syncWithLocation } = useContext(RefineContext);
 
-    return { syncWithLocation };
+  return { syncWithLocation };
 };

package/src/hooks/refine/useTitle.tsx

@@ -9,7 +9,7 @@ import { TitleProps } from "../../interfaces";
  * @see {@link https://refine.dev/docs/api-reference/core/hooks/refine/useTitle} for more details.
  */
 export const useTitle: () => React.FC<TitleProps> | undefined = () => {
-    const { Title } = useContext(RefineContext);
+  const { Title } = useContext(RefineContext);
 
-    return Title;
+  return Title;
 };

package/src/hooks/refine/useWarnAboutChange/index.ts

@@ -3,14 +3,14 @@ import { useContext } from "react";
 import { RefineContext } from "@contexts/refine";
 import { UnsavedWarnContext } from "@contexts/unsavedWarn";
 import {
-    IRefineContextOptions,
-    IUnsavedWarnContext,
+  IRefineContextOptions,
+  IUnsavedWarnContext,
 } from "../../../interfaces";
 
 type UseWarnAboutChangeType = () => {
-    warnWhenUnsavedChanges: IRefineContextOptions["warnWhenUnsavedChanges"];
-    warnWhen: NonNullable<IUnsavedWarnContext["warnWhen"]>;
-    setWarnWhen: NonNullable<IUnsavedWarnContext["setWarnWhen"]>;
+  warnWhenUnsavedChanges: IRefineContextOptions["warnWhenUnsavedChanges"];
+  warnWhen: NonNullable<IUnsavedWarnContext["warnWhen"]>;
+  setWarnWhen: NonNullable<IUnsavedWarnContext["setWarnWhen"]>;
 };
 
 /**
@@ -20,13 +20,13 @@ type UseWarnAboutChangeType = () => {
  * @see {@link https://refine.dev/docs/api-reference/core/components/refine-config#warnwhenunsavedchanges} for more details.
  */
 export const useWarnAboutChange: UseWarnAboutChangeType = () => {
-    const { warnWhenUnsavedChanges } = useContext(RefineContext);
+  const { warnWhenUnsavedChanges } = useContext(RefineContext);
 
-    const { warnWhen, setWarnWhen } = useContext(UnsavedWarnContext);
+  const { warnWhen, setWarnWhen } = useContext(UnsavedWarnContext);
 
-    return {
-        warnWhenUnsavedChanges,
-        warnWhen: Boolean(warnWhen),
-        setWarnWhen: setWarnWhen ?? (() => undefined),
-    };
+  return {
+    warnWhenUnsavedChanges,
+    warnWhen: Boolean(warnWhen),
+    setWarnWhen: setWarnWhen ?? (() => undefined),
+  };
 };