@refinedev/antd 5.37.4 → 5.37.6

package/src/hooks/table/useTable/paginationLink.tsx

@@ -2,26 +2,26 @@ import { useLink, useRouterContext, useRouterType } from "@refinedev/core";
 import React, { ReactNode } from "react";
 
 interface PaginationLinkProps {
-    to: string;
-    element: ReactNode;
+  to: string;
+  element: ReactNode;
 }
 
 export const PaginationLink = ({ to, element }: PaginationLinkProps) => {
-    const { Link: LegacyLink } = useRouterContext();
-    const routerType = useRouterType();
-    const Link = useLink();
+  const { Link: LegacyLink } = useRouterContext();
+  const routerType = useRouterType();
+  const Link = useLink();
 
-    const ActiveLink = routerType === "legacy" ? LegacyLink : Link;
+  const ActiveLink = routerType === "legacy" ? LegacyLink : Link;
 
-    return (
-        <ActiveLink
-            to={to}
-            replace={false}
-            onClick={(e: React.PointerEvent<HTMLButtonElement>) => {
-                e.preventDefault();
-            }}
-        >
-            {element}
-        </ActiveLink>
-    );
+  return (
+    <ActiveLink
+      to={to}
+      replace={false}
+      onClick={(e: React.PointerEvent<HTMLButtonElement>) => {
+        e.preventDefault();
+      }}
+    >
+      {element}
+    </ActiveLink>
+  );
 };

package/src/hooks/table/useTable/useTable.ts

@@ -2,39 +2,36 @@ import React, { Children, createElement, Fragment } from "react";
 import { Grid, FormProps, Form, TablePaginationConfig, TableProps } from "antd";
 import { useForm as useFormSF } from "sunflower-antd";
 
-import { SorterResult } from "antd/lib/table/interface";
-
 import {
-    useLiveMode,
-    BaseRecord,
-    CrudFilters,
-    HttpError,
-    useTable as useTableCore,
-    useTableProps as useTablePropsCore,
-    useTableReturnType as useTableCoreReturnType,
-    pickNotDeprecated,
+  useLiveMode,
+  BaseRecord,
+  CrudFilters,
+  HttpError,
+  useTable as useTableCore,
+  useTableProps as useTablePropsCore,
+  useTableReturnType as useTableCoreReturnType,
+  pickNotDeprecated,
 } from "@refinedev/core";
 
 import {
-    mapAntdSorterToCrudSorting,
-    mapAntdFilterToCrudFilter,
+  mapAntdSorterToCrudSorting,
+  mapAntdFilterToCrudFilter,
 } from "@definitions/table";
 import { PaginationLink } from "./paginationLink";
+import { FilterValue, SorterResult } from "../../../definitions/table";
 
 export type useTableProps<TQueryFnData, TError, TSearchVariables, TData> =
-    useTablePropsCore<TQueryFnData, TError, TData> & {
-        onSearch?: (
-            data: TSearchVariables,
-        ) => CrudFilters | Promise<CrudFilters>;
-    };
+  useTablePropsCore<TQueryFnData, TError, TData> & {
+    onSearch?: (data: TSearchVariables) => CrudFilters | Promise<CrudFilters>;
+  };
 
 export type useTableReturnType<
-    TData extends BaseRecord = BaseRecord,
-    TError extends HttpError = HttpError,
-    TSearchVariables = unknown,
+  TData extends BaseRecord = BaseRecord,
+  TError extends HttpError = HttpError,
+  TSearchVariables = unknown,
 > = useTableCoreReturnType<TData, TError> & {
-    searchFormProps: FormProps<TSearchVariables>;
-    tableProps: TableProps<TData>;
+  searchFormProps: FormProps<TSearchVariables>;
+  tableProps: TableProps<TData>;
 };
 
 /**
@@ -52,219 +49,212 @@ export type useTableReturnType<
  */
 
 export const useTable = <
-    TQueryFnData extends BaseRecord = BaseRecord,
-    TError extends HttpError = HttpError,
-    TSearchVariables = unknown,
-    TData extends BaseRecord = TQueryFnData,
+  TQueryFnData extends BaseRecord = BaseRecord,
+  TError extends HttpError = HttpError,
+  TSearchVariables = unknown,
+  TData extends BaseRecord = TQueryFnData,
 >({
-    onSearch,
+  onSearch,
+  initialCurrent,
+  initialPageSize,
+  hasPagination = true,
+  pagination,
+  initialSorter,
+  permanentSorter,
+  initialFilter,
+  permanentFilter,
+  defaultSetFilterBehavior,
+  filters: filtersFromProp,
+  sorters: sortersFromProp,
+  syncWithLocation,
+  resource,
+  successNotification,
+  errorNotification,
+  queryOptions,
+  liveMode: liveModeFromProp,
+  onLiveEvent,
+  liveParams,
+  meta,
+  metaData,
+  dataProviderName,
+}: useTableProps<
+  TQueryFnData,
+  TError,
+  TSearchVariables,
+  TData
+> = {}): useTableReturnType<TData, TError, TSearchVariables> => {
+  const {
+    tableQueryResult,
+    current,
+    setCurrent,
+    pageSize,
+    setPageSize,
+    filters,
+    setFilters,
+    sorters,
+    setSorters,
+    sorter,
+    setSorter,
+    createLinkForSyncWithLocation,
+    pageCount,
+    overtime,
+  } = useTableCore<TQueryFnData, TError, TData>({
+    permanentSorter,
+    permanentFilter,
     initialCurrent,
     initialPageSize,
-    hasPagination = true,
     pagination,
-    initialSorter,
-    permanentSorter,
-    initialFilter,
-    permanentFilter,
-    defaultSetFilterBehavior,
+    hasPagination,
     filters: filtersFromProp,
     sorters: sortersFromProp,
+    initialSorter,
+    initialFilter,
     syncWithLocation,
     resource,
+    defaultSetFilterBehavior,
     successNotification,
     errorNotification,
     queryOptions,
     liveMode: liveModeFromProp,
     onLiveEvent,
     liveParams,
-    meta,
-    metaData,
+    meta: pickNotDeprecated(meta, metaData),
+    metaData: pickNotDeprecated(meta, metaData),
     dataProviderName,
-}: useTableProps<
-    TQueryFnData,
-    TError,
-    TSearchVariables,
-    TData
-> = {}): useTableReturnType<TData, TError, TSearchVariables> => {
-    const {
-        tableQueryResult,
-        current,
-        setCurrent,
-        pageSize,
-        setPageSize,
-        filters,
-        setFilters,
-        sorters,
-        setSorters,
-        sorter,
-        setSorter,
-        createLinkForSyncWithLocation,
-        pageCount,
-        overtime,
-    } = useTableCore<TQueryFnData, TError, TData>({
-        permanentSorter,
-        permanentFilter,
-        initialCurrent,
-        initialPageSize,
-        pagination,
-        hasPagination,
-        filters: filtersFromProp,
-        sorters: sortersFromProp,
-        initialSorter,
-        initialFilter,
-        syncWithLocation,
-        resource,
-        defaultSetFilterBehavior,
-        successNotification,
-        errorNotification,
-        queryOptions,
-        liveMode: liveModeFromProp,
-        onLiveEvent,
-        liveParams,
-        meta: pickNotDeprecated(meta, metaData),
-        metaData: pickNotDeprecated(meta, metaData),
-        dataProviderName,
-    });
-    const breakpoint = Grid.useBreakpoint();
-    const [form] = Form.useForm<TSearchVariables>();
-    const formSF = useFormSF<any, TSearchVariables>({
-        form: form,
-    });
-    const liveMode = useLiveMode(liveModeFromProp);
+  });
+  const breakpoint = Grid.useBreakpoint();
+  const [form] = Form.useForm<TSearchVariables>();
+  const formSF = useFormSF<any, TSearchVariables>({
+    form: form,
+  });
+  const liveMode = useLiveMode(liveModeFromProp);
 
-    const hasPaginationString = hasPagination === false ? "off" : "server";
-    const isPaginationEnabled =
-        (pagination?.mode ?? hasPaginationString) !== "off";
+  const hasPaginationString = hasPagination === false ? "off" : "server";
+  const isPaginationEnabled =
+    (pagination?.mode ?? hasPaginationString) !== "off";
 
-    const preferredInitialFilters = pickNotDeprecated(
-        filtersFromProp?.initial,
-        initialFilter,
-    );
-
-    const { data, isFetched, isLoading } = tableQueryResult;
-
-    const onChange = (
-        paginationState: TablePaginationConfig,
-        tableFilters: Record<
-            string,
-            (string | number | boolean) | (string | number | boolean)[] | null
-        >,
-        sorter: SorterResult<any> | SorterResult<any>[],
-    ) => {
-        if (tableFilters && Object.keys(tableFilters).length > 0) {
-            // Map Antd:Filter -> refine:CrudFilter
-            const crudFilters = mapAntdFilterToCrudFilter(
-                tableFilters,
-                filters,
-                preferredInitialFilters,
-            );
-            setFilters(crudFilters);
-        }
+  const preferredInitialFilters = pickNotDeprecated(
+    filtersFromProp?.initial,
+    initialFilter,
+  );
 
-        if (sorter && Object.keys(sorter).length > 0) {
-            // Map Antd:Sorter -> refine:CrudSorting
-            const crudSorting = mapAntdSorterToCrudSorting(sorter);
-            setSorters(crudSorting);
-        }
+  const { data, isFetched, isLoading } = tableQueryResult;
 
-        if (isPaginationEnabled) {
-            setCurrent?.(paginationState.current || 1);
-            setPageSize?.(paginationState.pageSize || 10);
-        }
-    };
+  const onChange = (
+    paginationState: TablePaginationConfig,
+    tableFilters: Record<string, FilterValue | null>,
+    sorter: SorterResult | SorterResult[],
+  ) => {
+    if (tableFilters && Object.keys(tableFilters).length > 0) {
+      // Map Antd:Filter -> refine:CrudFilter
+      const crudFilters = mapAntdFilterToCrudFilter(
+        tableFilters,
+        filters,
+        preferredInitialFilters,
+      );
+      setFilters(crudFilters);
+    }
 
-    const onFinish = async (value: TSearchVariables) => {
-        if (onSearch) {
-            const searchFilters = await onSearch(value);
-            setFilters(searchFilters);
+    if (sorter && Object.keys(sorter).length > 0) {
+      // Map Antd:Sorter -> refine:CrudSorting
+      const crudSorting = mapAntdSorterToCrudSorting(sorter);
+      setSorters(crudSorting);
+    }
 
-            if (isPaginationEnabled) {
-                setCurrent?.(1);
-            }
-        }
-    };
+    if (isPaginationEnabled) {
+      setCurrent?.(paginationState.current || 1);
+      setPageSize?.(paginationState.pageSize || 10);
+    }
+  };
 
-    const antdPagination = (): false | TablePaginationConfig => {
-        if (isPaginationEnabled) {
-            return {
-                itemRender: (page, type, element) => {
-                    const link = createLinkForSyncWithLocation({
-                        pagination: {
-                            pageSize,
-                            current: page,
-                        },
-                        sorters,
-                        filters,
-                    });
+  const onFinish = async (value: TSearchVariables) => {
+    if (onSearch) {
+      const searchFilters = await onSearch(value);
+      setFilters(searchFilters);
 
-                    if (type === "page") {
-                        return createElement(PaginationLink, {
-                            to: link,
-                            element: `${page}`,
-                        });
-                    }
-                    if (type === "next" || type === "prev") {
-                        return createElement(PaginationLink, {
-                            to: link,
-                            element: element,
-                        });
-                    }
+      if (isPaginationEnabled) {
+        setCurrent?.(1);
+      }
+    }
+  };
 
-                    if (type === "jump-next" || type === "jump-prev") {
-                        const elementChildren = (element as React.ReactElement)
-                            ?.props?.children;
+  const antdPagination = (): false | TablePaginationConfig => {
+    if (isPaginationEnabled) {
+      return {
+        itemRender: (page, type, element) => {
+          const link = createLinkForSyncWithLocation({
+            pagination: {
+              pageSize,
+              current: page,
+            },
+            sorters,
+            filters,
+          });
 
-                        return createElement(PaginationLink, {
-                            to: link,
-                            element:
-                                Children.count(elementChildren) > 1
-                                    ? createElement(
-                                          Fragment,
-                                          {},
-                                          elementChildren,
-                                      )
-                                    : elementChildren,
-                        });
-                    }
+          if (type === "page") {
+            return createElement(PaginationLink, {
+              to: link,
+              element: `${page}`,
+            });
+          }
+          if (type === "next" || type === "prev") {
+            return createElement(PaginationLink, {
+              to: link,
+              element: element,
+            });
+          }
 
-                    return element;
-                },
-                pageSize,
-                current,
-                simple: !breakpoint.sm,
-                position: !breakpoint.sm ? ["bottomCenter"] : ["bottomRight"],
-                total: data?.total,
-            };
-        }
+          if (type === "jump-next" || type === "jump-prev") {
+            const elementChildren = (element as React.ReactElement)?.props
+              ?.children;
 
-        return false;
-    };
+            return createElement(PaginationLink, {
+              to: link,
+              element:
+                Children.count(elementChildren) > 1
+                  ? createElement(Fragment, {}, elementChildren)
+                  : elementChildren,
+            });
+          }
 
-    return {
-        searchFormProps: {
-            ...formSF.formProps,
-            onFinish,
-        },
-        tableProps: {
-            dataSource: data?.data,
-            loading: liveMode === "auto" ? isLoading : !isFetched,
-            onChange,
-            pagination: antdPagination(),
-            scroll: { x: true },
+          return element;
         },
-        tableQueryResult,
-        sorters,
-        sorter,
-        filters,
-        setSorters,
-        setSorter,
-        setFilters,
-        current,
-        setCurrent,
         pageSize,
-        setPageSize,
-        pageCount,
-        createLinkForSyncWithLocation,
-        overtime,
-    };
+        current,
+        simple: !breakpoint.sm,
+        position: !breakpoint.sm ? ["bottomCenter"] : ["bottomRight"],
+        total: data?.total,
+      };
+    }
+
+    return false;
+  };
+
+  return {
+    searchFormProps: {
+      ...formSF.formProps,
+      onFinish,
+    },
+    tableProps: {
+      dataSource: data?.data,
+      loading: liveMode === "auto" ? isLoading : !isFetched,
+      onChange,
+      pagination: antdPagination(),
+      scroll: { x: true },
+    },
+    tableQueryResult,
+    sorters,
+    sorter,
+    filters,
+    setSorters,
+    setSorter,
+    setFilters,
+    current,
+    setCurrent,
+    pageSize,
+    setPageSize,
+    pageCount,
+    createLinkForSyncWithLocation,
+    overtime,
+  };
 };

package/src/hooks/useFileUploadState/index.ts

@@ -2,33 +2,33 @@ import { useCallback, useMemo, useState } from "react";
 import { UploadChangeParam } from "antd/lib/upload";
 
 export type UseFileUploadStateType = () => {
-    isLoading: boolean;
-    onChange: (info: UploadChangeParam) => void;
+  isLoading: boolean;
+  onChange: (info: UploadChangeParam) => void;
 };
 
 export const useFileUploadState: UseFileUploadStateType = () => {
-    const [isLoading, setIsloading] = useState(false);
+  const [isLoading, setIsloading] = useState(false);
 
-    const onChange = useCallback((info: UploadChangeParam) => {
-        const fileListLoadings = mapStatusToLoading(info.fileList);
+  const onChange = useCallback((info: UploadChangeParam) => {
+    const fileListLoadings = mapStatusToLoading(info.fileList);
 
-        if (fileListLoadings.includes(true)) {
-            setIsloading(true);
-        } else {
-            setIsloading(false);
-        }
-    }, []);
+    if (fileListLoadings.includes(true)) {
+      setIsloading(true);
+    } else {
+      setIsloading(false);
+    }
+  }, []);
 
-    return useMemo(() => ({ isLoading, onChange }), [isLoading]);
+  return useMemo(() => ({ isLoading, onChange }), [isLoading]);
 };
 
 const mapStatusToLoading = (files: UploadChangeParam["fileList"]) => {
-    return files.map((file) => {
-        switch (file.status) {
-            case "uploading":
-                return true;
-            default:
-                return false;
-        }
-    });
+  return files.map((file) => {
+    switch (file.status) {
+      case "uploading":
+        return true;
+      default:
+        return false;
+    }
+  });
 };

package/src/hooks/useSiderVisible/index.ts

@@ -3,27 +3,27 @@ import { useContext } from "react";
 import { ThemedLayoutContext } from "@contexts";
 
 export type UseSiderVisibleType = {
-    siderVisible: boolean;
-    drawerSiderVisible: boolean;
-    setSiderVisible: (visible: boolean) => void;
-    setDrawerSiderVisible: (visible: boolean) => void;
+  siderVisible: boolean;
+  drawerSiderVisible: boolean;
+  setSiderVisible: (visible: boolean) => void;
+  setDrawerSiderVisible: (visible: boolean) => void;
 };
 
 /**
  * @deprecated Please use `useThemedLayoutContext` instead.
  */
 export const useSiderVisible = (): UseSiderVisibleType => {
-    const {
-        mobileSiderOpen,
-        siderCollapsed,
-        setMobileSiderOpen,
-        setSiderCollapsed,
-    } = useContext(ThemedLayoutContext);
+  const {
+    mobileSiderOpen,
+    siderCollapsed,
+    setMobileSiderOpen,
+    setSiderCollapsed,
+  } = useContext(ThemedLayoutContext);
 
-    return {
-        siderVisible: mobileSiderOpen,
-        setSiderVisible: setMobileSiderOpen,
-        drawerSiderVisible: siderCollapsed,
-        setDrawerSiderVisible: setSiderCollapsed,
-    };
+  return {
+    siderVisible: mobileSiderOpen,
+    setSiderVisible: setMobileSiderOpen,
+    drawerSiderVisible: siderCollapsed,
+    setDrawerSiderVisible: setSiderCollapsed,
+  };
 };

package/src/hooks/useThemedLayoutContext/index.ts

@@ -6,17 +6,17 @@ import { IThemedLayoutContext } from "@contexts/themedLayoutContext/IThemedLayou
 export type UseThemedLayoutContextType = IThemedLayoutContext;
 
 export const useThemedLayoutContext = (): UseThemedLayoutContextType => {
-    const {
-        mobileSiderOpen,
-        siderCollapsed,
-        setMobileSiderOpen,
-        setSiderCollapsed,
-    } = useContext(ThemedLayoutContext);
+  const {
+    mobileSiderOpen,
+    siderCollapsed,
+    setMobileSiderOpen,
+    setSiderCollapsed,
+  } = useContext(ThemedLayoutContext);
 
-    return {
-        mobileSiderOpen,
-        siderCollapsed,
-        setMobileSiderOpen,
-        setSiderCollapsed,
-    };
+  return {
+    mobileSiderOpen,
+    siderCollapsed,
+    setMobileSiderOpen,
+    setSiderCollapsed,
+  };
 };

package/src/index.tsx

@@ -4,10 +4,10 @@ export * from "./components";
 export * from "./contexts";
 
 export {
-    getDefaultSortOrder,
-    getDefaultFilter,
-    mapAntdSorterToCrudSorting,
-    mapAntdFilterToCrudFilter,
+  getDefaultSortOrder,
+  getDefaultFilter,
+  mapAntdSorterToCrudSorting,
+  mapAntdFilterToCrudFilter,
 } from "./definitions/table";
 export { getValueFromEvent } from "./definitions/upload";
 

package/src/interfaces/field.ts

@@ -1,3 +1,3 @@
 export type FieldProps<T> = {
-    value: T;
+  value: T;
 };

package/src/interfaces/index.ts

@@ -1,22 +1,21 @@
 import { IResourceItem } from "@refinedev/core";
 
 export type BaseRecord = {
-    id?: string;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    [key: string]: any;
+  id?: string;
+  [key: string]: any;
 };
 export interface Option {
-    label: string;
-    value: string;
+  label: string;
+  value: string;
 }
 
 export type ITreeMenu = IMenuItem & {
-    children: ITreeMenu[];
+  children: ITreeMenu[];
 };
 
 export type IMenuItem = IResourceItem & {
-    key: string;
-    route: string;
+  key: string;
+  route: string;
 };
 
 export * from "./field";