@refinedev/core 4.47.2 → 4.48.0

package/src/contexts/refine/index.tsx

@@ -3,97 +3,97 @@ import pluralize from "pluralize";
 import { humanizeString } from "../../definitions/helpers/humanizeString";
 
 import {
-    IRefineContextOptions,
-    IRefineContext,
-    IRefineContextProvider,
+  IRefineContextOptions,
+  IRefineContext,
+  IRefineContextProvider,
 } from "./IRefineContext";
 import { DefaultLayout } from "@components/layoutWrapper/defaultLayout";
 
 import { LoginPage as DefaultLoginPage } from "@components/pages";
 
 export const defaultRefineOptions: IRefineContextOptions = {
-    mutationMode: "pessimistic",
-    syncWithLocation: false,
-    undoableTimeout: 5000,
-    warnWhenUnsavedChanges: false,
-    liveMode: "off",
-    redirect: {
-        afterCreate: "list",
-        afterClone: "list",
-        afterEdit: "list",
-    },
-    overtime: {
-        interval: 1000,
-    },
-    textTransformers: {
-        humanize: humanizeString,
-        plural: pluralize.plural,
-        singular: pluralize.singular,
-    },
-    disableServerSideValidation: false,
+  mutationMode: "pessimistic",
+  syncWithLocation: false,
+  undoableTimeout: 5000,
+  warnWhenUnsavedChanges: false,
+  liveMode: "off",
+  redirect: {
+    afterCreate: "list",
+    afterClone: "list",
+    afterEdit: "list",
+  },
+  overtime: {
+    interval: 1000,
+  },
+  textTransformers: {
+    humanize: humanizeString,
+    plural: pluralize.plural,
+    singular: pluralize.singular,
+  },
+  disableServerSideValidation: false,
 };
 
 export const RefineContext = React.createContext<IRefineContext>({
-    hasDashboard: false,
-    mutationMode: "pessimistic",
-    warnWhenUnsavedChanges: false,
-    syncWithLocation: false,
-    undoableTimeout: 5000,
-    Title: undefined,
-    Sider: undefined,
-    Header: undefined,
-    Footer: undefined,
-    Layout: DefaultLayout,
-    OffLayoutArea: undefined,
-    liveMode: "off",
-    onLiveEvent: undefined,
-    options: defaultRefineOptions,
+  hasDashboard: false,
+  mutationMode: "pessimistic",
+  warnWhenUnsavedChanges: false,
+  syncWithLocation: false,
+  undoableTimeout: 5000,
+  Title: undefined,
+  Sider: undefined,
+  Header: undefined,
+  Footer: undefined,
+  Layout: DefaultLayout,
+  OffLayoutArea: undefined,
+  liveMode: "off",
+  onLiveEvent: undefined,
+  options: defaultRefineOptions,
 });
 
 export const RefineContextProvider: React.FC<IRefineContextProvider> = ({
-    hasDashboard,
-    mutationMode,
-    warnWhenUnsavedChanges,
-    syncWithLocation,
-    undoableTimeout,
-    children,
-    DashboardPage,
-    Title,
-    Layout = DefaultLayout,
-    Header,
-    Sider,
-    Footer,
-    OffLayoutArea,
-    LoginPage = DefaultLoginPage,
-    catchAll,
-    liveMode = "off",
-    onLiveEvent,
-    options,
+  hasDashboard,
+  mutationMode,
+  warnWhenUnsavedChanges,
+  syncWithLocation,
+  undoableTimeout,
+  children,
+  DashboardPage,
+  Title,
+  Layout = DefaultLayout,
+  Header,
+  Sider,
+  Footer,
+  OffLayoutArea,
+  LoginPage = DefaultLoginPage,
+  catchAll,
+  liveMode = "off",
+  onLiveEvent,
+  options,
 }) => {
-    return (
-        <RefineContext.Provider
-            value={{
-                __initialized: true,
-                hasDashboard,
-                mutationMode,
-                warnWhenUnsavedChanges,
-                syncWithLocation,
-                Title,
-                undoableTimeout,
-                Layout,
-                Header,
-                Sider,
-                Footer,
-                OffLayoutArea,
-                DashboardPage,
-                LoginPage,
-                catchAll,
-                liveMode,
-                onLiveEvent,
-                options,
-            }}
-        >
-            {children}
-        </RefineContext.Provider>
-    );
+  return (
+    <RefineContext.Provider
+      value={{
+        __initialized: true,
+        hasDashboard,
+        mutationMode,
+        warnWhenUnsavedChanges,
+        syncWithLocation,
+        Title,
+        undoableTimeout,
+        Layout,
+        Header,
+        Sider,
+        Footer,
+        OffLayoutArea,
+        DashboardPage,
+        LoginPage,
+        catchAll,
+        liveMode,
+        onLiveEvent,
+        options,
+      }}
+    >
+      {children}
+    </RefineContext.Provider>
+  );
 };

package/src/contexts/resource/IResourceContext.ts

@@ -2,67 +2,67 @@ import { ComponentType } from "react";
 import { UseQueryResult } from "@tanstack/react-query";
 import { ILogData } from "../../interfaces";
 import {
-    IResourceItem,
-    ResourceMeta,
-    ResourceProps,
+  IResourceItem,
+  ResourceMeta,
+  ResourceProps,
 } from "../../interfaces/bindings/resource";
 const auditLogPermissions = ["create", "update", "delete"] as const;
 
 export type ResourceRouteComponent = ComponentType<
-    IResourceComponentsProps<any, any>
+  IResourceComponentsProps<any, any>
 >;
 
 export type ResourceRoutePath = string;
 
 export type ResourceRouteDefinition = {
-    path: ResourceRoutePath;
-    component: ResourceRouteComponent;
+  path: ResourceRoutePath;
+  component: ResourceRouteComponent;
 };
 
 export type ResourceRouteComposition =
-    | ResourceRouteDefinition
-    | ResourceRoutePath
-    | ResourceRouteComponent;
+  | ResourceRouteDefinition
+  | ResourceRoutePath
+  | ResourceRouteComponent;
 
 export interface IResourceComponents {
-    list?: ResourceRouteComposition;
-    create?: ResourceRouteComposition;
-    clone?: ResourceRouteComposition;
-    edit?: ResourceRouteComposition;
-    show?: ResourceRouteComposition;
+  list?: ResourceRouteComposition;
+  create?: ResourceRouteComposition;
+  clone?: ResourceRouteComposition;
+  edit?: ResourceRouteComposition;
+  show?: ResourceRouteComposition;
 }
 
 type MetaProps<TExtends = { [key: string]: any }> = ResourceMeta & TExtends;
 
 export interface RouteableProperties {
-    canCreate?: boolean;
-    canEdit?: boolean;
-    canShow?: boolean;
-    canDelete?: boolean;
-    canList?: boolean;
+  canCreate?: boolean;
+  canEdit?: boolean;
+  canShow?: boolean;
+  canDelete?: boolean;
+  canList?: boolean;
 }
 
 export interface IResourceComponentsProps<
-    TCrudData = any,
-    TMetaPropsExtends = { [key: string]: any },
-    TLogQueryResult = ILogData,
+  TCrudData = any,
+  TMetaPropsExtends = { [key: string]: any },
+  TLogQueryResult = ILogData,
 > {
-    canCreate?: boolean;
-    canEdit?: boolean;
-    canDelete?: boolean;
-    canShow?: boolean;
-    name?: string;
-    initialData?: TCrudData;
-    /**
-     * @deprecated `options` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `options` for backward compatibility.
-     */
-    options?: MetaProps<TMetaPropsExtends>;
-    meta?: MetaProps<TMetaPropsExtends>;
-    logQueryResult?: UseQueryResult<TLogQueryResult>;
+  canCreate?: boolean;
+  canEdit?: boolean;
+  canDelete?: boolean;
+  canShow?: boolean;
+  name?: string;
+  initialData?: TCrudData;
+  /**
+   * @deprecated `options` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `options` for backward compatibility.
+   */
+  options?: MetaProps<TMetaPropsExtends>;
+  meta?: MetaProps<TMetaPropsExtends>;
+  logQueryResult?: UseQueryResult<TLogQueryResult>;
 }
 
 export { IResourceItem, ResourceProps };
 
 export interface IResourceContext {
-    resources: IResourceItem[];
+  resources: IResourceItem[];
 }

package/src/contexts/resource/index.tsx

@@ -2,33 +2,33 @@ import React from "react";
 
 import { IResourceContext } from "./IResourceContext";
 import {
-    IResourceItem,
-    ResourceProps,
+  IResourceItem,
+  ResourceProps,
 } from "../../interfaces/bindings/resource";
 import { useDeepMemo } from "@hooks/deepMemo";
 import { legacyResourceTransform } from "@definitions/helpers";
 
 export {
-    IResourceItem,
-    IResourceComponents,
-    IResourceComponentsProps,
-    IResourceContext,
+  IResourceItem,
+  IResourceComponents,
+  IResourceComponentsProps,
+  IResourceContext,
 } from "../../interfaces/bindings/resource";
 
 export const ResourceContext = React.createContext<IResourceContext>({
-    resources: [],
+  resources: [],
 });
 
 export const ResourceContextProvider: React.FC<
-    React.PropsWithChildren<{ resources: ResourceProps[] }>
+  React.PropsWithChildren<{ resources: ResourceProps[] }>
 > = ({ resources: providedResources, children }) => {
-    const resources: IResourceItem[] = useDeepMemo(() => {
-        return legacyResourceTransform(providedResources ?? []);
-    }, [providedResources]);
+  const resources: IResourceItem[] = useDeepMemo(() => {
+    return legacyResourceTransform(providedResources ?? []);
+  }, [providedResources]);
 
-    return (
-        <ResourceContext.Provider value={{ resources }}>
-            {children}
-        </ResourceContext.Provider>
-    );
+  return (
+    <ResourceContext.Provider value={{ resources }}>
+      {children}
+    </ResourceContext.Provider>
+  );
 };

package/src/contexts/router/index.tsx

@@ -4,14 +4,14 @@ import { RouterBindings } from "src/interfaces";
 const defaultBindings = {};
 
 export const RouterBindingsContext =
-    createContext<RouterBindings>(defaultBindings);
+  createContext<RouterBindings>(defaultBindings);
 
 export const RouterBindingsProvider: React.FC<
-    PropsWithChildren<{ router?: RouterBindings }>
+  PropsWithChildren<{ router?: RouterBindings }>
 > = ({ children, router }) => {
-    return (
-        <RouterBindingsContext.Provider value={router ?? defaultBindings}>
-            {children}
-        </RouterBindingsContext.Provider>
-    );
+  return (
+    <RouterBindingsContext.Provider value={router ?? defaultBindings}>
+      {children}
+    </RouterBindingsContext.Provider>
+  );
 };

package/src/contexts/router-picker/index.tsx

@@ -16,6 +16,6 @@ export const RouterPickerProvider = RouterPickerContext.Provider;
  * @internal This is an internal hook.
  */
 export const useRouterType = () => {
-    const value = React.useContext(RouterPickerContext);
-    return value;
+  const value = React.useContext(RouterPickerContext);
+  return value;
 };

package/src/contexts/translation/ITranslationContext.ts

@@ -1,19 +1,19 @@
 import { ReactNode } from "react";
 
 export type Translate = (
-    key: string,
-    options?: any,
-    defaultMessage?: string,
+  key: string,
+  options?: any,
+  defaultMessage?: string,
 ) => string;
 
 export interface I18nProvider {
-    translate: Translate;
-    changeLocale: (locale: string, options?: any) => Promise<any>;
-    getLocale: () => string;
+  translate: Translate;
+  changeLocale: (locale: string, options?: any) => Promise<any>;
+  getLocale: () => string;
 }
 
 export interface ITranslationContext {
-    i18nProvider?: I18nProvider;
+  i18nProvider?: I18nProvider;
 }
 
 export type TranslationProvider = Required<ITranslationContext>;

package/src/contexts/translation/index.tsx

@@ -8,17 +8,17 @@ export const defaultProvider: ITranslationContext = {};
 export const TranslationContext = React.createContext<ITranslationContext>({});
 
 export const TranslationContextProvider: React.FC<
-    ITranslationContext & {
-        children?: React.ReactNode;
-    }
+  ITranslationContext & {
+    children?: React.ReactNode;
+  }
 > = ({ children, i18nProvider }) => {
-    return (
-        <TranslationContext.Provider
-            value={{
-                i18nProvider: i18nProvider,
-            }}
-        >
-            {children}
-        </TranslationContext.Provider>
-    );
+  return (
+    <TranslationContext.Provider
+      value={{
+        i18nProvider: i18nProvider,
+      }}
+    >
+      {children}
+    </TranslationContext.Provider>
+  );
 };

package/src/contexts/undoableQueue/IUndoableQueueContext.ts

@@ -1,6 +1,6 @@
 import { IUndoableQueue } from "../../interfaces";
 
 export interface IUndoableQueueContext {
-    notifications: IUndoableQueue[];
-    notificationDispatch: React.Dispatch<any>;
+  notifications: IUndoableQueue[];
+  notificationDispatch: React.Dispatch<any>;
 }

package/src/contexts/undoableQueue/actionTypes.ts

@@ -1,5 +1,5 @@
 export enum ActionTypes {
-    ADD = "ADD",
-    REMOVE = "REMOVE",
-    DECREASE_NOTIFICATION_SECOND = "DECREASE_NOTIFICATION_SECOND",
+  ADD = "ADD",
+  REMOVE = "REMOVE",
+  DECREASE_NOTIFICATION_SECOND = "DECREASE_NOTIFICATION_SECOND",
 }

package/src/contexts/undoableQueue/index.ts

@@ -1,5 +1,5 @@
 export { ActionTypes } from "./actionTypes";
 export {
-    UndoableQueueContextProvider,
-    UndoableQueueContext,
+  UndoableQueueContextProvider,
+  UndoableQueueContext,
 } from "./undoableQueueContext";

package/src/contexts/undoableQueue/undoableQueueContext.tsx

@@ -7,77 +7,76 @@ import { IUndoableQueue, IUndoableQueueContext } from "../../interfaces";
 import { ActionTypes } from "./actionTypes";
 
 export const UndoableQueueContext = React.createContext<IUndoableQueueContext>({
-    notifications: [],
-    notificationDispatch: () => false,
+  notifications: [],
+  notificationDispatch: () => false,
 });
 
 const initialState: IUndoableQueue[] = [];
 
 export const undoableQueueReducer = (state: IUndoableQueue[], action: any) => {
-    switch (action.type) {
-        case ActionTypes.ADD:
-            const newState = state.filter(
-                (notificationItem: IUndoableQueue) => {
-                    return !(
-                        isEqual(notificationItem.id, action.payload.id) &&
-                        notificationItem.resource == action.payload.resource
-                    );
-                },
-            );
+  switch (action.type) {
+    case ActionTypes.ADD: {
+      const newState = state.filter((notificationItem: IUndoableQueue) => {
+        return !(
+          isEqual(notificationItem.id, action.payload.id) &&
+          notificationItem.resource === action.payload.resource
+        );
+      });
 
-            return [
-                ...newState,
-                {
-                    ...action.payload,
-                    isRunning: true,
-                },
-            ];
-        case ActionTypes.REMOVE:
-            return state.filter(
-                (notificationItem: IUndoableQueue) =>
-                    !(
-                        isEqual(notificationItem.id, action.payload.id) &&
-                        notificationItem.resource == action.payload.resource
-                    ),
-            );
-        case ActionTypes.DECREASE_NOTIFICATION_SECOND:
-            return state.map((notificationItem: IUndoableQueue) => {
-                if (
-                    isEqual(notificationItem.id, action.payload.id) &&
-                    notificationItem.resource == action.payload.resource
-                ) {
-                    return {
-                        ...notificationItem,
-                        seconds: action.payload.seconds - 1000,
-                    };
-                }
-                return notificationItem;
-            });
-        default:
-            return state;
+      return [
+        ...newState,
+        {
+          ...action.payload,
+          isRunning: true,
+        },
+      ];
     }
+    case ActionTypes.REMOVE:
+      return state.filter(
+        (notificationItem: IUndoableQueue) =>
+          !(
+            isEqual(notificationItem.id, action.payload.id) &&
+            notificationItem.resource === action.payload.resource
+          ),
+      );
+    case ActionTypes.DECREASE_NOTIFICATION_SECOND:
+      return state.map((notificationItem: IUndoableQueue) => {
+        if (
+          isEqual(notificationItem.id, action.payload.id) &&
+          notificationItem.resource === action.payload.resource
+        ) {
+          return {
+            ...notificationItem,
+            seconds: action.payload.seconds - 1000,
+          };
+        }
+        return notificationItem;
+      });
+    default:
+      return state;
+  }
 };
 
 export const UndoableQueueContextProvider: React.FC<{
-    children: ReactNode;
+  children: ReactNode;
 }> = ({ children }) => {
-    const [notifications, notificationDispatch] = useReducer(
-        undoableQueueReducer,
-        initialState,
-    );
+  const [notifications, notificationDispatch] = useReducer(
+    undoableQueueReducer,
+    initialState,
+  );
 
-    const notificationData = { notifications, notificationDispatch };
+  const notificationData = { notifications, notificationDispatch };
 
-    return (
-        <UndoableQueueContext.Provider value={notificationData}>
-            {children}
-            {typeof window !== "undefined" &&
-                notifications.map((notification) => (
-                    <UndoableQueue
-                        key={`${notification.id}-${notification.resource}-queue`}
-                        notification={notification}
-                    />
-                ))}
-        </UndoableQueueContext.Provider>
-    );
+  return (
+    <UndoableQueueContext.Provider value={notificationData}>
+      {children}
+      {typeof window !== "undefined" &&
+        notifications.map((notification) => (
+          <UndoableQueue
+            key={`${notification.id}-${notification.resource}-queue`}
+            notification={notification}
+          />
+        ))}
+    </UndoableQueueContext.Provider>
+  );
 };

package/src/contexts/unsavedWarn/IUnsavedWarnContext.ts

@@ -1,4 +1,4 @@
 export interface IUnsavedWarnContext {
-    warnWhen?: boolean;
-    setWarnWhen?: (value: boolean) => void;
+  warnWhen?: boolean;
+  setWarnWhen?: (value: boolean) => void;
 }

package/src/contexts/unsavedWarn/index.tsx

@@ -5,13 +5,13 @@ import { IUnsavedWarnContext } from "./IUnsavedWarnContext";
 export const UnsavedWarnContext = React.createContext<IUnsavedWarnContext>({});
 
 export const UnsavedWarnContextProvider: React.FC<{ children: ReactNode }> = ({
-    children,
+  children,
 }) => {
-    const [warnWhen, setWarnWhen] = useState(false);
+  const [warnWhen, setWarnWhen] = useState(false);
 
-    return (
-        <UnsavedWarnContext.Provider value={{ warnWhen, setWarnWhen }}>
-            {children}
-        </UnsavedWarnContext.Provider>
-    );
+  return (
+    <UnsavedWarnContext.Provider value={{ warnWhen, setWarnWhen }}>
+      {children}
+    </UnsavedWarnContext.Provider>
+  );
 };