@antscorp/antsomi-ui 1.3.7-beta.57 → 1.3.7-beta.59

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

@@ -123,16 +123,60 @@ export const AddDynamicContent = props => {
     // Template Custom
     const [templateId, settemplateId] = useState();
     const queryClient = useQueryClient();
-    const { data: listBoAttributes = [], isFetching: isFetchingListBoAttr, isError: isErrorBoAttr, error: listBoAttributesError, } = useGetListAttributeBO({
+    const { data: listBoAttributes = [], isFetching: isFetchingListBoAttr, isError: isErrorBoAttr, } = 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, error: dynamicContentAttrError, } = useGetDynamicContentAttr({ url }, infos);
-    const { data: listSources, isFetching: isFetchingSourceBO, isError: isErrorListSources, error: listSourcesError, } = useGetListSourceByEvent({
+    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({
         apiConfig: {
             url,
         },
@@ -140,6 +184,9 @@ export const AddDynamicContent = props => {
         eventActionId,
         eventCategoryId,
         options: {
+            onSuccess: () => {
+                setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.SOURCE]: false });
+            },
             select: (data) => {
                 const { rows } = data || {};
                 return rows.map((row) => ({
@@ -147,14 +194,39 @@ 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, isError: isErrorListEvents, error: listEventsError, } = useGetListAllEvents({
+    const { data: listEvents, isFetching: isFetchingEventBySource } = 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) => ({
@@ -164,13 +236,38 @@ export const AddDynamicContent = props => {
             },
         },
     });
-    const { data: listEventAttributes, isFetching: isFetchingEventAttr, isError: isErrorEventAttr, error: listEventAttributesError, } = useGetListEventAttr({ url }, infos, selectedEventSource || '', Array.isArray(selectedSource) ? selectedSource.join(',') : selectedSource || '', {
+    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,
+            });
+        },
         select: (data) => serilizeEventAttr(data, language, additionalAttrProperties),
     });
-    const { data: listPromotionPools, isFetching: isFetchingPromotionPool, isError: isErrorListPromotionPools, error: listPromotionPoolsError, } = useGetListPromotionPool({ url }, infos, {
+    const { data: listPromotionPools, isFetching: isFetchingPromotionPool } = useGetListPromotionPool({ url }, infos, {
+        onSuccess: () => {
+            setHasError({
+                [DYNAMIC_CONTENT_SETTING_KEY.PROMOTION_POOL]: false,
+            });
+        },
         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, error: listPromotionCodeAttributesError, } = useGetListPromotionCodeAttr({ url }, infos, {
+    const { data: listPromotionCodeAttributes, isFetching: isFetchingPromotionCodeAttr, isError: isErrorListPromotionCodeAttr, } = useGetListPromotionCodeAttr({ url }, infos, {
+        onSuccess: () => {
+            setHasError({ [DYNAMIC_CONTENT_SETTING_KEY.ATTRIBUTE]: false });
+        },
         select: (data) => data
             .filter((attr) => +attr?.status === 1)
             .map((attr) => ({
@@ -181,6 +278,16 @@ 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 },
@@ -188,122 +295,6 @@ 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?: Omit<UseQueryOptions, 'queryKey' | 'queryFn'>;
+    queryOptions?: UseQueryOptions;
     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, Error>;
+export declare const useGetAbstractUsers: ({ queryOptions, params, search, queryFn, }: Props) => import("@tanstack/react-query").UseQueryResult<unknown, unknown>;
 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: (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>>;
+    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>>;
     onLoadMore: () => void;
     onChange: (newValue: Partial<TemplateValueOptions>) => void;
 };

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

@@ -134,8 +134,7 @@ 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({
-                        queryKey: [QUERY_KEYS.GET_LIST_SAVED_MEDIA, domainMedia, slug, paramsMemo],
+                    queryClient.invalidateQueries([QUERY_KEYS.GET_LIST_SAVED_MEDIA, domainMedia, slug, paramsMemo], {
                         exact: false,
                     });
                 }
@@ -211,7 +210,7 @@ export const UploadImage = props => {
                     })));
                     await Promise.all(arrPromise);
                     setLoading(false);
-                    refetch();
+                    refetch({ refetchPage: (_page, index) => index === 0 });
                 }
                 else {
                     setLoading(false);

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

@@ -45,49 +45,50 @@ const Settings = (props) => {
         token,
         userId,
         accountId,
-    });
-    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');
+    }, {
+        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;
-            }
-            const newRanking = valueRanking;
-            if (groupId && itemTypeId) {
-                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) {
+                    // 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,
+                            },
                         },
-                    },
-                });
-                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 { keepPreviousData, useQueryClient } from '@tanstack/react-query';
+import { useQueryClient } from '@tanstack/react-query';
 // Types
 import { useAppConfigContext } from '@antscorp/antsomi-ui/es/providers';
 // Components
@@ -181,8 +181,7 @@ export function useDataTableListing(props) {
         },
         options: {
             enabled: isEnabledFetchMatchesAny,
-            initialPageParam: 1,
-            placeholderData: keepPreviousData,
+            keepPreviousData: true,
             retry: false,
             getNextPageParam(lastPage, allPages) {
                 // Extract the total number of items from the last fetched page
@@ -226,7 +225,7 @@ export function useDataTableListing(props) {
         },
         options: {
             queryKey: [name],
-            placeholderData: keepPreviousData,
+            keepPreviousData: true,
             enabled: !!listingAuth?.url && !!listingAuth?.token && enabledApiListing,
             ...queryOptions?.getTableListing,
         },
@@ -240,7 +239,7 @@ export function useDataTableListing(props) {
             request: restOfApiSearchRequest,
         },
         options: {
-            placeholderData: keepPreviousData,
+            keepPreviousData: true,
             enabled: !!searchAuth?.url && !!searchAuth?.token && enabledApiSearch,
             ...queryOptions?.getSearchListing,
         },
@@ -849,8 +848,7 @@ export function useDataTableListing(props) {
     }, [mainColumnKey, tableData]);
     /** Refetch */
     const refetchTableListing = useCallback(() => {
-        queryClient.invalidateQueries({
-            queryKey: [QUERY_KEYS.GET_DATA_TABLE_LISTING, name],
+        queryClient.invalidateQueries([QUERY_KEYS.GET_DATA_TABLE_LISTING, name], {
             exact: false,
         });
     }, [name, queryClient]);

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

@@ -6,10 +6,7 @@ const getListUserServices = async (params = {}, domain, token, config, userId) =
     return res.data;
 };
 export const useGetListUser = ({ domain, config, userId, token }) => {
-    const { data, isFetching } = useQuery({
-        queryKey: [QUERY_KEY, domain, token, config, userId],
-        queryFn: () => getListUserServices({}, domain, token, config, userId),
-    });
+    const { data, isFetching } = useQuery([QUERY_KEY, domain, token, config, userId], () => 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, isPending: isDashboardRemoving } = useRemoveDashboard();
+    const { mutateAsync: removeDashboard, isLoading: 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: NoInfer<import("@antscorp/antsomi-ui/es/models/LeftMenu").FeatureMenuPermission[]> | undefined;
+    menuListPermission: 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,10 +2,7 @@ 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({
-        queryKey: [QUERY_KEYS.GET_ACCOUNT_PERMISSION, domainPermission, token, config, userId, ownerId],
-        queryFn: () => Service.permission.callApi.getList(params, domainPermission, token, config, userId, 'list-menu', 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));
     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: (options?: import("@tanstack/react-query").RefetchOptions | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, Error>>;
+    refetchTicket: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, unknown>>;
 };
 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: (options?: import("@tanstack/react-query").RefetchOptions | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, Error>>;
+    refetchComments: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<any, unknown>>;
 };
 export {};

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

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

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

@@ -3,6 +3,7 @@ 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;
@@ -68,8 +69,8 @@ export declare const useTemplateListing: <T = undefined>(options: TemplateListin
     isLoadingCategoryList: boolean;
     isLoadingTemplateList: boolean;
     isLoadingTemplateDetail: boolean;
-    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>>;
+    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>>;
     onChangeCheckedCategories: (checkedCategories: TCheckedCategories) => void;
     onChangeOpenCategoryKeys: (openKeys: string[]) => void;
     onRemoveObjectTemplate: (id: TThumbnailCardId) => void;

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

@@ -9,15 +9,15 @@ export declare const AntsomiAIQueries: {
             refine_prompt: string;
             sql_suggestion: string;
             summary: string;
-        }, Error, Record<string, unknown>, unknown>;
+        }, unknown, Record<string, unknown>, unknown>;
         generateSQLAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
             key: string;
             prompt: string;
             refine_prompt: string;
             sql_suggestion: string;
             summary: string;
-        }, Error, Record<string, unknown>, unknown>;
-        isPending: boolean;
+        }, unknown, Record<string, unknown>, unknown>;
+        isLoading: 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;
-    }, Error, Record<string, unknown>, unknown>;
+    }, unknown, Record<string, unknown>, unknown>;
     generateSQLAsync: import("@tanstack/react-query").UseMutateAsyncFunction<{
         key: string;
         prompt: string;
         refine_prompt: string;
         sql_suggestion: string;
         summary: string;
-    }, Error, Record<string, unknown>, unknown>;
-    isPending: boolean;
+    }, unknown, Record<string, unknown>, unknown>;
+    isLoading: 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, isPending, isError, } = useMutation({
+    const { mutate: generateSQL, mutateAsync: generateSQLAsync, isLoading, isError, } = useMutation({
         mutationFn: async (data) => AIServices.generateSQL({
             auth,
             data,
             env,
         }),
     });
-    return { generateSQL, generateSQLAsync, isPending, isError };
+    return { generateSQL, generateSQLAsync, isLoading, isError };
 };