@antscorp/antsomi-ui 1.3.7-beta.53 → 1.3.7-beta.54

package/es/components/molecules/AddDynamicContent/AddDynamicContent.js

@@ -123,60 +123,16 @@ export const AddDynamicContent = props => {
     // Template Custom
     const [templateId, settemplateId] = useState();
     const queryClient = useQueryClient();
-    const { data: listBoAttributes = [], isFetching: isFetchingListBoAttr, isError: isErrorBoAttr, } = useGetListAttributeBO({
+    const { data: listBoAttributes = [], isFetching: isFetchingListBoAttr, isError: isErrorBoAttr, error: listBoAttributesError, } = useGetListAttributeBO({
         url,
         itemTypeIds: itemTypeId ? [itemTypeId] : [],
         options: {
-            onSuccess: (data) => {
-                setHasError({
-                    [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: false,
-                    [DYNAMIC_CONTENT_SETTING_KEY.INDEX]: false,
-                });
-                if (data.length &&
-                    selectedDynamicContentType &&
-                    regexCSType.test(selectedDynamicContentType)) {
-                    if (form.getFieldValue(DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE) &&
-                        form.getFieldValue(DYNAMIC_CONTENT_SETTING_KEY.INDEX))
-                        return;
-                    form.setFieldsValue({
-                        [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: data[0],
-                        [DYNAMIC_CONTENT_SETTING_KEY.INDEX]: defaultDynamicIndex,
-                    });
-                }
-            },
             select: (data) => serilizeBOAttr(data, additionalAttrProperties),
-            onError: (error) => {
-                setHasError({
-                    [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true,
-                    [DYNAMIC_CONTENT_SETTING_KEY.INDEX]: true,
-                });
-                handleError(error, {
-                    path: PATH,
-                    name: 'useGetListAttributeBO',
-                    args: error?.message,
-                });
-            },
             enabled: !!itemTypeId,
         },
     }, infos);
-    const { data: dynamicContentAttr, isFetching: isFetchingDynamicContentAttr, isError: isErrorDynamicContentAttr, } = useGetDynamicContentAttr({ url }, infos, {
-        onSuccess: () => {
-            setHasError({
-                [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: false,
-            });
-        },
-        onError: (error) => {
-            setHasError({
-                [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true,
-            });
-            handleError(error, {
-                path: PATH,
-                name: 'useGetDynamicContentAttr',
-                args: error?.message,
-            });
-        },
-    });
-    const { data: listSources, isFetching: isFetchingSourceBO } = useGetListSourceByEvent({
+    const { data: dynamicContentAttr, isFetching: isFetchingDynamicContentAttr, isError: isErrorDynamicContentAttr, error: dynamicContentAttrError, } = useGetDynamicContentAttr({ url }, infos);
+    const { data: listSources, isFetching: isFetchingSourceBO, isError: isErrorListSources, error: listSourcesError, } = useGetListSourceByEvent({
         apiConfig: {
             url,
         },
@@ -184,9 +140,6 @@ export const AddDynamicContent = props => {
         eventActionId,
         eventCategoryId,
         options: {
-            onSuccess: () => {
-                setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.SOURCE]: false });
-            },
             select: (data) => {
                 const { rows } = data || {};
                 return rows.map((row) => ({
@@ -194,39 +147,14 @@ export const AddDynamicContent = props => {
                     value: row.value,
                 }));
             },
-            onError: (error) => {
-                setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.SOURCE]: true });
-                handleError(error, {
-                    path: PATH,
-                    name: 'useGetListSourceBO',
-                    args: error?.message,
-                });
-            },
         },
     });
-    const { data: listEvents, isFetching: isFetchingEventBySource } = useGetListAllEvents({
+    const { data: listEvents, isFetching: isFetchingEventBySource, isError: isErrorListEvents, error: listEventsError, } = useGetListAllEvents({
         apiConfig: {
             url,
         },
         infos,
         options: {
-            onSuccess: (data) => {
-                setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.EVENT]: false });
-                if (!isEmpty(data) &&
-                    selectedDynamicContentType === DYNAMIC_CONTENT_TYPE.EVENT_ATTRIBUTE.value) {
-                    form.setFieldsValue({
-                        [DYNAMIC_CONTENT_SETTING_KEY.EVENT]: data[0].value,
-                    });
-                }
-            },
-            onError: (error) => {
-                setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.EVENT]: true });
-                handleError(error, {
-                    path: PATH,
-                    name: 'useGetListEventBySource',
-                    args: error?.message,
-                });
-            },
             select: (data) => {
                 const { rows = [] } = data || {};
                 return rows.map((event) => ({
@@ -236,38 +164,13 @@ export const AddDynamicContent = props => {
             },
         },
     });
-    const { data: listEventAttributes, isFetching: isFetchingEventAttr, isError: isErrorEventAttr, } = useGetListEventAttr({ url }, infos, selectedEventSource || '', Array.isArray(selectedSource) ? selectedSource.join(',') : selectedSource || '', {
-        onSuccess: () => setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: false }),
-        onError: (error) => {
-            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true });
-            handleError(error, {
-                path: PATH,
-                name: 'useGetListEventAttr',
-                args: error?.message,
-            });
-        },
+    const { data: listEventAttributes, isFetching: isFetchingEventAttr, isError: isErrorEventAttr, error: listEventAttributesError, } = useGetListEventAttr({ url }, infos, selectedEventSource || '', Array.isArray(selectedSource) ? selectedSource.join(',') : selectedSource || '', {
         select: (data) => serilizeEventAttr(data, language, additionalAttrProperties),
     });
-    const { data: listPromotionPools, isFetching: isFetchingPromotionPool } = useGetListPromotionPool({ url }, infos, {
-        onSuccess: () => {
-            setHasError({
-                [DYNAMIC_CONTENT_SETTING_KEY.PROMOTION_POOL]: false,
-            });
-        },
+    const { data: listPromotionPools, isFetching: isFetchingPromotionPool, isError: isErrorListPromotionPools, error: listPromotionPoolsError, } = useGetListPromotionPool({ url }, infos, {
         select: (data) => serilizePromotionPool(data, additionalAttrProperties),
-        onError: (error) => {
-            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true });
-            handleError(error, {
-                path: PATH,
-                name: 'useGetListPromotionPool',
-                args: error?.message,
-            });
-        },
     });
-    const { data: listPromotionCodeAttributes, isFetching: isFetchingPromotionCodeAttr, isError: isErrorListPromotionCodeAttr, } = useGetListPromotionCodeAttr({ url }, infos, {
-        onSuccess: () => {
-            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: false });
-        },
+    const { data: listPromotionCodeAttributes, isFetching: isFetchingPromotionCodeAttr, isError: isErrorListPromotionCodeAttr, error: listPromotionCodeAttributesError, } = useGetListPromotionCodeAttr({ url }, infos, {
         select: (data) => data
             .filter((attr) => +attr?.status === 1)
             .map((attr) => ({
@@ -278,16 +181,6 @@ export const AddDynamicContent = props => {
             disabled: parseInt(attr.status) === 4,
             status: attr.status,
         })),
-        onError: (error) => {
-            setHasError({
-                [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true,
-            });
-            handleError(error, {
-                path: PATH,
-                name: 'useGetPromotionCodeAttr',
-                args: error?.message,
-            });
-        },
     });
     const { data: eventTrackingAttributes } = useGetEventTrackingAttributes({
         apiConfig: { url },
@@ -295,6 +188,122 @@ export const AddDynamicContent = props => {
         eventActionId,
         eventCategoryId,
     });
+    // Handle success/error side effects (TanStack Query v5 removed onSuccess/onError on useQuery)
+    useEffect(() => {
+        if (isErrorBoAttr) {
+            setHasError({
+                [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true,
+                [DYNAMIC_CONTENT_SETTING_KEY.INDEX]: true,
+            });
+            handleError(listBoAttributesError, {
+                path: PATH,
+                name: 'useGetListAttributeBO',
+                args: listBoAttributesError?.message,
+            });
+            return;
+        }
+        if (listBoAttributes) {
+            setHasError({
+                [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: false,
+                [DYNAMIC_CONTENT_SETTING_KEY.INDEX]: false,
+            });
+            if (listBoAttributes.length &&
+                selectedDynamicContentType &&
+                regexCSType.test(selectedDynamicContentType)) {
+                if (form.getFieldValue(DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE) &&
+                    form.getFieldValue(DYNAMIC_CONTENT_SETTING_KEY.INDEX))
+                    return;
+                form.setFieldsValue({
+                    [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: listBoAttributes[0],
+                    [DYNAMIC_CONTENT_SETTING_KEY.INDEX]: defaultDynamicIndex,
+                });
+            }
+        }
+    }, [listBoAttributes, isErrorBoAttr, selectedDynamicContentType, defaultDynamicIndex]);
+    useEffect(() => {
+        if (isErrorDynamicContentAttr) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true });
+            handleError(dynamicContentAttrError, {
+                path: PATH,
+                name: 'useGetDynamicContentAttr',
+                args: dynamicContentAttrError?.message,
+            });
+        }
+        else if (dynamicContentAttr) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: false });
+        }
+    }, [dynamicContentAttr, isErrorDynamicContentAttr]);
+    useEffect(() => {
+        if (isErrorListSources) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.SOURCE]: true });
+            handleError(listSourcesError, {
+                path: PATH,
+                name: 'useGetListSourceBO',
+                args: listSourcesError?.message,
+            });
+        }
+        else if (listSources) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.SOURCE]: false });
+        }
+    }, [listSources, isErrorListSources]);
+    useEffect(() => {
+        if (isErrorListEvents) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.EVENT]: true });
+            handleError(listEventsError, {
+                path: PATH,
+                name: 'useGetListEventBySource',
+                args: listEventsError?.message,
+            });
+            return;
+        }
+        if (listEvents &&
+            !isEmpty(listEvents) &&
+            selectedDynamicContentType === DYNAMIC_CONTENT_TYPE.EVENT_ATTRIBUTE.value) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.EVENT]: false });
+            form.setFieldsValue({
+                [DYNAMIC_CONTENT_SETTING_KEY.EVENT]: listEvents[0].value,
+            });
+        }
+    }, [listEvents, isErrorListEvents, selectedDynamicContentType]);
+    useEffect(() => {
+        if (isErrorEventAttr) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true });
+            handleError(listEventAttributesError, {
+                path: PATH,
+                name: 'useGetListEventAttr',
+                args: listEventAttributesError?.message,
+            });
+        }
+        else if (listEventAttributes) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: false });
+        }
+    }, [listEventAttributes, isErrorEventAttr]);
+    useEffect(() => {
+        if (isErrorListPromotionPools) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true });
+            handleError(listPromotionPoolsError, {
+                path: PATH,
+                name: 'useGetListPromotionPool',
+                args: listPromotionPoolsError?.message,
+            });
+        }
+        else if (listPromotionPools) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.PROMOTION_POOL]: false });
+        }
+    }, [listPromotionPools, isErrorListPromotionPools]);
+    useEffect(() => {
+        if (isErrorListPromotionCodeAttr) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: true });
+            handleError(listPromotionCodeAttributesError, {
+                path: PATH,
+                name: 'useGetPromotionCodeAttr',
+                args: listPromotionCodeAttributesError?.message,
+            });
+        }
+        else if (listPromotionCodeAttributes) {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: false });
+        }
+    }, [listPromotionCodeAttributes, isErrorListPromotionCodeAttr]);
     // Memo
     const isShowEventIndexField = useDeepCompareMemo(() => {
         if (selectedAttr && selectedDynamicContentType === DYNAMIC_CONTENT_TYPE.EVENT_ATTRIBUTE.value) {

package/es/components/molecules/SelectAccount/hook/useGetAbstractUsers.d.ts

@@ -1,11 +1,11 @@
 import { UseQueryOptions } from '@tanstack/react-query';
 type Props = {
-    queryOptions?: UseQueryOptions;
+    queryOptions?: Omit<UseQueryOptions, 'queryKey' | 'queryFn'>;
     params?: Record<string, any>;
     search?: string;
     queryFn?: Function;
     enabled?: boolean;
     defaultDataSource?: any;
 };
-export declare const useGetAbstractUsers: ({ queryOptions, params, search, queryFn, }: Props) => import("@tanstack/react-query").UseQueryResult<unknown, unknown>;
+export declare const useGetAbstractUsers: ({ queryOptions, params, search, queryFn, }: Props) => import("@tanstack/react-query").UseQueryResult<unknown, Error>;
 export {};

package/es/components/molecules/TemplateSaveAs/hooks/useTemplateSave.d.ts

@@ -65,8 +65,8 @@ export declare const useTemplateSave: (options: TemplateListingOptions) => {
     };
     form: import("antd").FormInstance<FormValue>;
     errors: any[] | undefined;
-    refetchCategoryList: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<TemplateCategory[], any>>;
-    refetchTemplateList: <TPageData_1>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData_1>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<any>, any>>;
+    refetchCategoryList: (options?: import("@tanstack/react-query").RefetchOptions | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<TemplateCategory[]>, any>>;
+    refetchTemplateList: (options?: import("@tanstack/react-query").RefetchOptions | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, any>>;
     onLoadMore: () => void;
     onChange: (newValue: Partial<TemplateValueOptions>) => void;
 };

package/es/components/molecules/UploadImage/index.js

@@ -134,7 +134,8 @@ export const UploadImage = props => {
             if (res && res.data && res.data.code === 200 && res.data.data) {
                 const { success_media = [] } = res.data.data;
                 if (Array.isArray(success_media) && success_media.length) {
-                    queryClient.invalidateQueries([QUERY_KEYS.GET_LIST_SAVED_MEDIA, domainMedia, slug, paramsMemo], {
+                    queryClient.invalidateQueries({
+                        queryKey: [QUERY_KEYS.GET_LIST_SAVED_MEDIA, domainMedia, slug, paramsMemo],
                         exact: false,
                     });
                 }
@@ -210,7 +211,7 @@ export const UploadImage = props => {
                     })));
                     await Promise.all(arrPromise);
                     setLoading(false);
-                    refetch({ refetchPage: (_page, index) => index === 0 });
+                    refetch();
                 }
                 else {
                     setLoading(false);

package/es/components/organism/ContentSources/Settings.js

@@ -45,50 +45,49 @@ const Settings = (props) => {
         token,
         userId,
         accountId,
-    }, {
-        onSuccess(data) {
-            if (!isInitDataCDPDone &&
-                (isCDP || justOneGroup) &&
-                isArray(data) &&
-                contentSources.groups.length === 1 &&
-                contentSources.groups[0] &&
-                !contentSources.groups[0].itemTypeId) {
-                const BOProduct = data.find(bo => +bo.id === PRODUCT_ITEM_TYPE_ID) || {};
-                const groupId = get(contentSources, 'groups[0].groupId', '');
-                const itemTypeId = BOProduct?.id;
-                const itemTypeDisplay = BOProduct?.label;
-                const itemTypeName = BOProduct?.name;
-                let valueRanking = GET_TOP_RANKING_DEFAULT;
-                if (itemTypeId === PRODUCT_ITEM_TYPE_ID) {
-                    valueRanking = PRODUCT_RANKING_DEFAULT;
-                    if (isCDP || justOneGroup) {
-                        set(valueRanking, 'algorithms.sort', 'order');
-                    }
-                }
-                else if (itemTypeName === ITEM_TYPE_NAME.ARTICLE) {
-                    valueRanking = ARTICLE_RANKING_DEFAULT;
+    });
+    useEffect(() => {
+        if (listBO &&
+            !isInitDataCDPDone &&
+            (isCDP || justOneGroup) &&
+            isArray(listBO) &&
+            contentSources.groups.length === 1 &&
+            contentSources.groups[0] &&
+            !contentSources.groups[0].itemTypeId) {
+            const BOProduct = listBO.find(bo => +bo.id === PRODUCT_ITEM_TYPE_ID) || {};
+            const groupId = get(contentSources, 'groups[0].groupId', '');
+            const itemTypeId = BOProduct?.id;
+            const itemTypeDisplay = BOProduct?.label;
+            const itemTypeName = BOProduct?.name;
+            let valueRanking = GET_TOP_RANKING_DEFAULT;
+            if (itemTypeId === PRODUCT_ITEM_TYPE_ID) {
+                valueRanking = PRODUCT_RANKING_DEFAULT;
+                if (isCDP || justOneGroup) {
+                    set(valueRanking, 'algorithms.sort', 'order');
                 }
-                const newRanking = valueRanking;
-                if (groupId && itemTypeId) {
-                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                    contentSourceDispatch({
-                        type: 'SET_CONTENT_SOURCE_GROUP',
-                        payload: {
-                            groupId,
-                            values: {
-                                itemTypeId,
-                                itemTypeDisplay,
-                                itemTypeName,
-                                ranking: newRanking,
-                                filters: FILTERS_DEFAULT,
-                            },
+            }
+            else if (itemTypeName === ITEM_TYPE_NAME.ARTICLE) {
+                valueRanking = ARTICLE_RANKING_DEFAULT;
+            }
+            const newRanking = valueRanking;
+            if (groupId && itemTypeId) {
+                contentSourceDispatch({
+                    type: 'SET_CONTENT_SOURCE_GROUP',
+                    payload: {
+                        groupId,
+                        values: {
+                            itemTypeId,
+                            itemTypeDisplay,
+                            itemTypeName,
+                            ranking: newRanking,
+                            filters: FILTERS_DEFAULT,
                         },
-                    });
-                    setIsInitDataCDPDone(true);
-                }
+                    },
+                });
+                setIsInitDataCDPDone(true);
             }
-        },
-    });
+        }
+    }, [listBO, isInitDataCDPDone, isCDP, justOneGroup, contentSources.groups]);
     const { data: listFallbackBO } = useGetListFallbackBO({
         serviceAuth,
     });

package/es/components/organism/DataTable/hooks/useDataTableListing/useDataTableListing.js

@@ -4,7 +4,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { Link } from 'react-router-dom';
 import { flatMap, isEmpty, pick, xor, groupBy as lodashGroupBy } from 'lodash';
-import { useQueryClient } from '@tanstack/react-query';
+import { keepPreviousData, useQueryClient } from '@tanstack/react-query';
 // Types
 import { useAppConfigContext } from '@antscorp/antsomi-ui/es/providers';
 // Components
@@ -181,7 +181,8 @@ export function useDataTableListing(props) {
         },
         options: {
             enabled: isEnabledFetchMatchesAny,
-            keepPreviousData: true,
+            initialPageParam: 1,
+            placeholderData: keepPreviousData,
             retry: false,
             getNextPageParam(lastPage, allPages) {
                 // Extract the total number of items from the last fetched page
@@ -225,7 +226,7 @@ export function useDataTableListing(props) {
         },
         options: {
             queryKey: [name],
-            keepPreviousData: true,
+            placeholderData: keepPreviousData,
             enabled: !!listingAuth?.url && !!listingAuth?.token && enabledApiListing,
             ...queryOptions?.getTableListing,
         },
@@ -239,7 +240,7 @@ export function useDataTableListing(props) {
             request: restOfApiSearchRequest,
         },
         options: {
-            keepPreviousData: true,
+            placeholderData: keepPreviousData,
             enabled: !!searchAuth?.url && !!searchAuth?.token && enabledApiSearch,
             ...queryOptions?.getSearchListing,
         },
@@ -848,7 +849,8 @@ export function useDataTableListing(props) {
     }, [mainColumnKey, tableData]);
     /** Refetch */
     const refetchTableListing = useCallback(() => {
-        queryClient.invalidateQueries([QUERY_KEYS.GET_DATA_TABLE_LISTING, name], {
+        queryClient.invalidateQueries({
+            queryKey: [QUERY_KEYS.GET_DATA_TABLE_LISTING, name],
             exact: false,
         });
     }, [name, queryClient]);

package/es/components/organism/Help/queries/useGetListUser.js

@@ -6,7 +6,10 @@ const getListUserServices = async (params = {}, domain, token, config, userId) =
     return res.data;
 };
 export const useGetListUser = ({ domain, config, userId, token }) => {
-    const { data, isFetching } = useQuery([QUERY_KEY, domain, token, config, userId], () => getListUserServices({}, domain, token, config, userId));
+    const { data, isFetching } = useQuery({
+        queryKey: [QUERY_KEY, domain, token, config, userId],
+        queryFn: () => getListUserServices({}, domain, token, config, userId),
+    });
     return {
         listUsers: data || [],
         isFetchingUsers: isFetching,

package/es/components/organism/LeftMenu/components/HomeMenu/useHomeMenu.js

@@ -35,7 +35,7 @@ export const useHomeMenu = (props) => {
         const dashboardMenu = flattenMenuPermission.find(menu => menu.menu_code === MENU_CODE.DASHBOARD);
         return !!dashboardMenu && dashboardMenu.selected_edit !== MENU_PERMISSION.NONE;
     }, [flattenMenuPermission]);
-    const { mutateAsync: removeDashboard, isLoading: isDashboardRemoving } = useRemoveDashboard();
+    const { mutateAsync: removeDashboard, isPending: isDashboardRemoving } = useRemoveDashboard();
     const onOptionCallback = useCallback((args) => {
         const { optionKey, menuItemKey } = args;
         switch (optionKey) {

package/es/components/organism/LeftMenu/hooks/usePermission.d.ts

@@ -2,6 +2,6 @@ export declare const usePermission: () => {
     mappingChildrenMenu: import("@antscorp/antsomi-ui/es/models/LeftMenu").TFeatureMenu[];
     permissionMenu: import("@antscorp/antsomi-ui/es/models/LeftMenu").TFeatureMenu[];
     activeItemPath: import("@antscorp/antsomi-ui/es/models/LeftMenu").TFeatureMenu[];
-    menuListPermission: import("@antscorp/antsomi-ui/es/models/LeftMenu").FeatureMenuPermission[] | undefined;
+    menuListPermission: NoInfer<import("@antscorp/antsomi-ui/es/models/LeftMenu").FeatureMenuPermission[]> | undefined;
     flattenMenuPermission: import("@antscorp/antsomi-ui/es/models/LeftMenu").FeatureMenuPermission[];
 };

package/es/components/organism/TicketEditorV2/queries/useFetchAccountPermission.js

@@ -2,7 +2,10 @@ import { useQuery } from '@tanstack/react-query';
 import { QUERY_KEYS } from '../constants';
 import Service from '../Service';
 export const useFetchAccountPermission = ({ params, domainPermission, token, config, userId, ownerId, }) => {
-    const { data, isFetching } = useQuery([QUERY_KEYS.GET_ACCOUNT_PERMISSION, domainPermission, token, config, userId, ownerId], () => Service.permission.callApi.getList(params, domainPermission, token, config, userId, 'list-menu', ownerId));
+    const { data, isFetching } = useQuery({
+        queryKey: [QUERY_KEYS.GET_ACCOUNT_PERMISSION, domainPermission, token, config, userId, ownerId],
+        queryFn: () => Service.permission.callApi.getList(params, domainPermission, token, config, userId, 'list-menu', ownerId),
+    });
     if (data?.code === 200) {
         return {
             accountEdit: data?.data[0]?.selected_edit,

package/es/components/organism/TicketEditorV2/queries/useGetDetailTicket.d.ts

@@ -8,6 +8,6 @@ type Props = {
 export declare const useGetDetailTicket: ({ domainTicket, config, userId, ticketId, networkId, }: Props) => {
     ticketDetails: any;
     isFetching: boolean;
-    refetchTicket: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, unknown>>;
+    refetchTicket: (options?: import("@tanstack/react-query").RefetchOptions | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, Error>>;
 };
 export {};

package/es/components/organism/TicketEditorV2/queries/useGetListComments.d.ts

@@ -9,6 +9,6 @@ type Props = {
 export declare const useGetListComments: ({ domainTicket, config, userId, ticketId, enabled, networkId, }: Props) => {
     listComments: any;
     isFetchingComments: boolean;
-    refetchComments: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, unknown>>;
+    refetchComments: (options?: import("@tanstack/react-query").RefetchOptions | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, Error>>;
 };
 export {};

package/es/components/organism/TicketEditorV2/queries/useGetListUser.js

@@ -6,7 +6,10 @@ const getListUserServices = async (params = {}, domain, token, config, userId) =
     return res.data;
 };
 export const useGetListUser = ({ domainTicket, config, userId }) => {
-    const { data, isFetching } = useQuery([QUERY_KEYS.GET_LIST_USER, domainTicket, '', config, userId], () => getListUserServices({}, domainTicket, '', config, userId));
+    const { data, isFetching } = useQuery({
+        queryKey: [QUERY_KEYS.GET_LIST_USER, domainTicket, '', config, userId],
+        queryFn: () => getListUserServices({}, domainTicket, '', config, userId),
+    });
     return {
         listUsers: data || [],
         isFetchingUsers: isFetching,

package/es/components/template/TemplateListing/hooks/useTemplateListing.d.ts

@@ -3,7 +3,6 @@ import { TServiceAuth } from '@antscorp/antsomi-ui/es/types';
 import { TCategoryItem, TCheckedCategories, TSelectTemplateAction, TTemplateItem } from '../types';
 import { TTemplateListingConfig } from '@antscorp/antsomi-ui/es/types/templateListing';
 import { TThumbnailCardId } from '../../../molecules/ThumbnailCard';
-import { InfiniteData } from '@tanstack/react-query';
 import { TemplateCategory } from '@antscorp/antsomi-ui/es/models/TemplateCategory';
 interface TemplateListingOptions {
     serviceAuth: TServiceAuth;
@@ -69,8 +68,8 @@ export declare const useTemplateListing: <T = undefined>(options: TemplateListin
     isLoadingCategoryList: boolean;
     isLoadingTemplateList: boolean;
     isLoadingTemplateDetail: boolean;
-    refetchCategoryList: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<TemplateCategory[], any>>;
-    refetchTemplateList: <TPageData_1>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData_1>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<InfiniteData<any>, any>>;
+    refetchCategoryList: (options?: import("@tanstack/react-query").RefetchOptions | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<TemplateCategory[]>, any>>;
+    refetchTemplateList: (options?: import("@tanstack/react-query").RefetchOptions | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, any>>;
     onChangeCheckedCategories: (checkedCategories: TCheckedCategories) => void;
     onChangeOpenCategoryKeys: (openKeys: string[]) => void;
     onRemoveObjectTemplate: (id: TThumbnailCardId) => void;

package/es/providers/ConfigProvider/ConfigProvider.js

@@ -82,6 +82,6 @@ const ConfigProvider = props => {
         const containers = document.getElementsByClassName('antsomi-scroll-box');
         handleScrollAction(Array.from(containers));
     }, []);
-    return (_jsx(AntdConfigProvider, { theme: theme, prefixCls: prefixCls, ...restOfProps, children: _jsx(AppConfigProvider, { value: appConfig, children: _jsx("div", { ref: ref, children: _jsxs(App, { children: [_jsx(GlobalStyle, {}), _jsx(StyleProvider, { hashPriority: "high", children: children }), _jsx(QueryDevtoolsAntsomiUI, { position: "bottom-right" })] }) }) }) }));
+    return (_jsx(AntdConfigProvider, { theme: theme, prefixCls: prefixCls, ...restOfProps, children: _jsx(AppConfigProvider, { value: appConfig, children: _jsx("div", { ref: ref, children: _jsxs(App, { children: [_jsx(GlobalStyle, {}), _jsx(StyleProvider, { hashPriority: "high", children: children }), _jsx(QueryDevtoolsAntsomiUI, { position: "bottom" })] }) }) }) }));
 };
 export default ConfigProvider;

package/es/queries/AI/index.d.ts

@@ -9,15 +9,15 @@ export declare const AntsomiAIQueries: {
             refine_prompt: string;
             sql_suggestion: string;
             summary: string;
-        }, unknown, Record<string, unknown>, unknown>;
+        }, Error, Record<string, unknown>, unknown>;
         generateSQLAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
             key: string;
             prompt: string;
             refine_prompt: string;
             sql_suggestion: string;
             summary: string;
-        }, unknown, Record<string, unknown>, unknown>;
-        isLoading: boolean;
+        }, Error, Record<string, unknown>, unknown>;
+        isPending: boolean;
         isError: boolean;
     };
 };

package/es/queries/AI/useSqlGeneration.d.ts

@@ -11,15 +11,15 @@ export declare const useSqlGeneration: (params: UseSqlGenerationParams) => {
         refine_prompt: string;
         sql_suggestion: string;
         summary: string;
-    }, unknown, Record<string, unknown>, unknown>;
+    }, Error, Record<string, unknown>, unknown>;
     generateSQLAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
         key: string;
         prompt: string;
         refine_prompt: string;
         sql_suggestion: string;
         summary: string;
-    }, unknown, Record<string, unknown>, unknown>;
-    isLoading: boolean;
+    }, Error, Record<string, unknown>, unknown>;
+    isPending: boolean;
     isError: boolean;
 };
 export {};

package/es/queries/AI/useSqlGeneration.js

@@ -2,12 +2,12 @@ import { useMutation } from '@tanstack/react-query';
 import { AIServices } from '../../services/AI';
 export const useSqlGeneration = (params) => {
     const { auth, env } = params;
-    const { mutate: generateSQL, mutateAsync: generateSQLAsync, isLoading, isError, } = useMutation({
+    const { mutate: generateSQL, mutateAsync: generateSQLAsync, isPending, isError, } = useMutation({
         mutationFn: async (data) => AIServices.generateSQL({
             auth,
             data,
             env,
         }),
     });
-    return { generateSQL, generateSQLAsync, isLoading, isError };
+    return { generateSQL, generateSQLAsync, isPending, isError };
 };