@fctc/widget-logic 5.3.7-beta.16 → 5.3.7-beta.18

package/dist/hooks.mjs

@@ -0,0 +1,958 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/hooks.ts
+import {
+  useModel,
+  useButton,
+  useChangeStatus,
+  useDelete,
+  useDeleteComment,
+  useDuplicateRecord,
+  useExecuteImport,
+  useExportExcel,
+  useForgotPassword,
+  useForgotPasswordSSO,
+  useGet2FAMethods,
+  useGetAccessByCode,
+  useGetActionDetail,
+  useGetAll,
+  useGetCalendar,
+  useGetComment,
+  useGetCompanyInfo,
+  useGetConversionRate,
+  useGetCurrency,
+  useGetCurrentCompany,
+  useGetDetail,
+  useGetFieldExport,
+  useGetFieldOnChange,
+  useGetFileExcel,
+  useGetFormView,
+  useGetGroups,
+  useGetListCompany,
+  useGetListData,
+  useGetListMyBankAccount,
+  useGetMenu,
+  useGetPrintReport,
+  useGetProGressBar,
+  useGetProfile,
+  useGetProvider,
+  useGetResequence,
+  useGetSelection,
+  useGetUser,
+  useGetView,
+  useGrantAccess,
+  useIsValidToken,
+  useLoadAction,
+  useLoadMessage,
+  useLoginCredential,
+  useLoginSocial,
+  useLogout,
+  useOdooDataTransform,
+  useOnChangeForm,
+  useParsePreview,
+  usePrint,
+  useRemoveRow,
+  useRemoveTotpSetup,
+  useRequestSetupTotp,
+  useResetPassword,
+  useResetPasswordSSO,
+  useRunAction,
+  useSave,
+  useSendComment,
+  useSettingsWebRead2fa,
+  useSignInSSO,
+  useSwitchLocale,
+  useUpdatePassword,
+  useUploadFile,
+  useUploadFileExcel,
+  useUploadIdFile,
+  useUploadImage,
+  useValidateActionToken,
+  useVerify2FA,
+  useVerifyTotp,
+  useAddEntity,
+  useChangeOrderPreparationState,
+  useCheckPayment,
+  useCreateEntity,
+  useCreatePosConfig,
+  useCreateSession,
+  useDeleteEntity,
+  useGenSerialNumber,
+  useGeneratePaymentQrInfo,
+  useGetASession,
+  useGetExternalTabs,
+  useGetList,
+  useGetOrderLine,
+  useReadGroup,
+  useGetPinCode
+} from "@fctc/interface-logic/hooks";
+
+// src/hooks/core/use-app-provider.tsx
+import { createContext, useContext, useMemo as useMemo4 } from "react";
+
+// src/hooks/core/use-menu.ts
+import { useState as useState2 } from "react";
+
+// src/hooks/core/use-call-action.ts
+import { useCallback, useState } from "react";
+
+// src/provider.ts
+var provider_exports = {};
+__reExport(provider_exports, provider_star);
+import * as provider_star from "@fctc/interface-logic/provider";
+
+// src/hooks/core/use-call-action.ts
+var useCallAction = () => {
+  const { env } = (0, provider_exports.useEnv)();
+  const { useLoadAction: useLoadAction2, useRunAction: useRunAction2 } = (0, provider_exports.useService)();
+  const queryLoadAction = useLoadAction2();
+  const queryRunAction = useRunAction2();
+  const [actionData, setActionData] = useState(
+    void 0
+  );
+  const callAction = useCallback(
+    async ({
+      aid,
+      service,
+      xNode,
+      context
+    }) => {
+      try {
+        const menuContext = {
+          ...env?.context,
+          ...context
+        };
+        const loadRes = await queryLoadAction.mutateAsync({
+          idAction: aid,
+          context: menuContext,
+          service,
+          xNode
+        });
+        if (loadRes?.result?.type === "ir.actions.server") {
+          const runRes = await queryRunAction.mutateAsync({
+            idAction: aid,
+            context: menuContext,
+            service,
+            xNode
+          });
+          setActionData(runRes?.result);
+          return runRes?.result;
+        } else {
+          setActionData(loadRes?.result);
+          return loadRes?.result;
+        }
+      } catch (err) {
+        console.error("callAction error:", err);
+        return void 0;
+      }
+    },
+    [env?.context?.lang]
+  );
+  return [actionData, callAction];
+};
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  STORAGES: () => STORAGES,
+  countSum: () => countSum,
+  guessTypeFromUrl: () => guessTypeFromUrl,
+  isObjectEmpty: () => isObjectEmpty,
+  languages: () => languages,
+  mergeButtons: () => mergeButtons,
+  setStorageItemAsync: () => setStorageItemAsync,
+  useStorageState: () => useStorageState
+});
+
+// src/utils/constants.ts
+var languages = [
+  { id: "vi_VN", name: "VIE" },
+  { id: "en_US", name: "ENG" }
+];
+
+// src/utils/function.ts
+import { useCallback as useCallback2, useEffect, useReducer } from "react";
+var countSum = (data, field) => {
+  if (!data || !field) return 0;
+  return data.reduce(
+    (total, item) => total + (item?.[`${field}_count`] || 0),
+    0
+  );
+};
+var isObjectEmpty = (obj) => {
+  return Object.keys(obj).length === 0;
+};
+function mergeButtons(fields) {
+  const buttons = fields?.filter((f) => f.type_co === "button");
+  const others = fields?.filter((f) => f.type_co !== "button");
+  if (buttons?.length) {
+    others.push({
+      type_co: "buttons",
+      buttons
+    });
+  }
+  return others;
+}
+var STORAGES = {
+  TOKEN: "accessToken",
+  USER_INFO: "USER_INFO"
+};
+function useAsyncState(initialValue = [true, null]) {
+  return useReducer(
+    (_state, action = null) => [false, action],
+    initialValue
+  );
+}
+async function setStorageItemAsync(key, value) {
+  try {
+    if (value === null) {
+      localStorage.removeItem(key);
+    } else {
+      localStorage.setItem(key, value);
+    }
+  } catch (e) {
+    console.error("Local storage is unavailable:", e);
+  }
+}
+function useStorageState(key) {
+  const [state, setState] = useAsyncState();
+  useEffect(() => {
+    try {
+      const storedValue = localStorage.getItem(key);
+      setState(storedValue);
+    } catch (e) {
+      console.error("Local storage is unavailable:", e);
+    }
+  }, [key]);
+  const setValue = useCallback2(
+    (value) => {
+      setState(value);
+      setStorageItemAsync(key, value);
+    },
+    [key]
+  );
+  return [state, setValue];
+}
+var guessTypeFromUrl = (url) => {
+  const ext = url.split(".").pop()?.toLowerCase();
+  if (!ext) return null;
+  const map = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    webp: "image/webp",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    bmp: "image/bmp",
+    tiff: "image/tiff",
+    pdf: "application/pdf",
+    zip: "application/zip",
+    rar: "application/x-rar-compressed",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    xls: "application/vnd.ms-excel",
+    mp4: "video/mp4",
+    mov: "video/quicktime"
+  };
+  return map[ext] || null;
+};
+
+// src/utils.ts
+__reExport(utils_exports, utils_star);
+import * as utils_star from "@fctc/interface-logic/utils";
+
+// src/hooks/core/use-menu.ts
+var useMenu = ({
+  context,
+  specification,
+  domain,
+  defaultService
+}) => {
+  const { useGetMenu: useGetMenu2 } = (0, provider_exports.useService)();
+  const [action, callAction] = useCallAction();
+  const [service, setService] = useState2("");
+  const [xNode, setXNode] = useState2("");
+  const menuData = useGetMenu2(
+    context,
+    specification,
+    !!context && !isObjectEmpty(context) && !!context?.uid && !!context?.lang,
+    domain,
+    defaultService
+  );
+  const [menuId, setMenuId] = useState2(void 0);
+  const handleChangeMenu = async ({
+    menu,
+    service: service2,
+    xNode: xNode2,
+    context: context2
+  }) => {
+    const aidMenu = menu?.action?.external_xml_id || menu?.action?.id?.id;
+    if (menu) {
+      setMenuId(menu.id?.toString() ?? "");
+    }
+    if (aidMenu) {
+      const actionResponse = await callAction({
+        aid: aidMenu,
+        service: service2 ?? "",
+        xNode: xNode2,
+        context: context2
+      });
+      setService(service2 ?? "");
+      setXNode(xNode2 ?? "");
+      return actionResponse;
+    }
+  };
+  return {
+    ...menuData,
+    service,
+    xNode,
+    data: menuData?.data,
+    action: { handleChangeMenu },
+    state: { menuId, action },
+    context,
+    isLoading: menuData.isLoading,
+    isError: menuData.isError,
+    error: menuData.error,
+    refetch: menuData.refetch
+  };
+};
+
+// src/hooks/core/use-detail.ts
+import { useQuery } from "@tanstack/react-query";
+import { useEffect as useEffect2 } from "react";
+var useDetail = (sub) => {
+  const { setUserInfo, env } = (0, provider_exports.useEnv)();
+  const { useGetDetail: useGetDetail2 } = (0, provider_exports.useService)();
+  const fetchGetDetail = useGetDetail2();
+  const userDetailQuery = useQuery({
+    queryKey: ["userDetailQuery", sub],
+    queryFn: () => {
+      return fetchGetDetail.mutateAsync({
+        model: "res.users",
+        ids: [sub],
+        specification: { image_256: {} },
+        service: env?.default_service
+      });
+    },
+    enabled: !!sub
+  });
+  useEffect2(() => {
+    if (userDetailQuery.data) {
+      const userPicture = userDetailQuery.data;
+      setUserInfo({ ...env?.user, image: userPicture?.[0]?.image_256 });
+    }
+  }, [userDetailQuery.isFetched]);
+  return { ...userDetailQuery };
+};
+
+// src/hooks/core/use-profile.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { useEffect as useEffect3, useMemo } from "react";
+var useProfile = ({
+  service,
+  i18n
+}) => {
+  const { setUid, setLang, setUserInfo, env } = (0, provider_exports.useEnv)();
+  const { useGetProfile: useGetProfile2 } = (0, provider_exports.useService)();
+  const getProfile = useGetProfile2(service);
+  const userInfoQuery = useQuery2({
+    queryKey: ["userInfo"],
+    queryFn: () => getProfile.mutateAsync(),
+    enabled: isObjectEmpty(env?.user)
+  });
+  useEffect3(() => {
+    if (userInfoQuery.data) {
+      const userInfo = userInfoQuery.data;
+      utils_exports.sessionStorageUtils.setXNode(userInfo?.x_node);
+      setUid(userInfo?.sub);
+      setUserInfo(userInfo);
+      const userLocale = languages.find((lang) => lang?.id === userInfo?.locale);
+      setLang(userLocale?.id);
+      i18n.changeLanguage(userLocale?.id.split("_")[0]);
+    }
+  }, [userInfoQuery.isFetched]);
+  const context = useMemo(() => {
+    if (userInfoQuery.data?.sub && userInfoQuery.data?.locale) {
+      return {
+        uid: Number(userInfoQuery.data.sub),
+        lang: String(userInfoQuery.data.locale),
+        tz: "Asia/Saigon"
+      };
+    }
+    return void 0;
+  }, [userInfoQuery.isFetched]);
+  if (userInfoQuery.isLoading || !userInfoQuery.data) {
+    return null;
+  }
+  return {
+    ...userInfoQuery,
+    context
+  };
+};
+
+// src/hooks/core/use-user.ts
+var useUser = ({ service, i18n }) => {
+  const userProfile = useProfile({ service, i18n });
+  const userDetail = useDetail(userProfile?.data?.sub);
+  return { userProfile, userDetail, context: userProfile?.context };
+};
+
+// src/hooks/core/use-view-v2.ts
+import { useMemo as useMemo2 } from "react";
+var useViewV2 = ({
+  action,
+  context,
+  aid,
+  service,
+  xNode
+}) => {
+  const { useGetView: useGetView2 } = (0, provider_exports.useService)();
+  const viewParams = useMemo2(() => {
+    if (!action || !action?.res_model) {
+      return void 0;
+    }
+    const actionResult = action;
+    return {
+      aid,
+      model: String(actionResult?.res_model),
+      views: [
+        ...Array.isArray(actionResult?.views) ? actionResult?.views.map(
+          (view2) => view2[1] === "list" ? [view2[0], "list"] : view2
+        ) : [],
+        [
+          Array.isArray(actionResult?.search_view_id) ? actionResult?.search_view_id[0] : actionResult?.search_view_id,
+          "search"
+        ]
+      ],
+      context,
+      id: isNaN(Number(aid)) ? action?.id : aid,
+      service,
+      xNode
+    };
+  }, [action, context, aid]);
+  const view = useGetView2({
+    viewParams: viewParams ?? {},
+    enabled: !!viewParams
+  });
+  return {
+    ...view,
+    context
+  };
+};
+
+// src/hooks/core/use-company.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { useEffect as useEffect4, useMemo as useMemo3 } from "react";
+var useCompany = ({ service }) => {
+  const { setCompanies, setDefaultCompany, env } = (0, provider_exports.useEnv)();
+  const { useGetCurrentCompany: useGetCurrentCompany2, useGetCompanyInfo: useGetCompanyInfo2 } = (0, provider_exports.useService)();
+  const getCurrentCompany = useGetCurrentCompany2();
+  const fetchCurrentCompany = async () => {
+    return await getCurrentCompany.mutateAsync({
+      service
+    });
+  };
+  const currentCompany = useQuery3({
+    queryKey: ["currentCompany"],
+    queryFn: fetchCurrentCompany,
+    enabled: !!env?.defaultCompany
+  });
+  const current_company_id = useMemo3(() => {
+    return currentCompany.data?.current_company_id;
+  }, [currentCompany.data]);
+  useEffect4(() => {
+    if (current_company_id) {
+      const companyIDs = [current_company_id];
+      setCompanies(companyIDs);
+    }
+  }, [current_company_id]);
+  const getCompanyInfo = useGetCompanyInfo2();
+  const companyInfo = useQuery3({
+    queryKey: ["companyInfoQuery", current_company_id],
+    queryFn: () => getCompanyInfo.mutateAsync({
+      service,
+      id: Number(current_company_id)
+    }),
+    enabled: !!current_company_id
+  });
+  useEffect4(() => {
+    if (companyInfo.data) {
+      const companyInfoData = companyInfo.data;
+      if (companyInfoData?.length) {
+        setDefaultCompany(companyInfoData[0]);
+      }
+    }
+  }, [companyInfo.data]);
+  if (!companyInfo?.data || !currentCompany?.data) return;
+  return {
+    currentCompany: { ...currentCompany },
+    companyInfo: { ...companyInfo }
+  };
+};
+
+// src/hooks/core/use-app-provider.tsx
+import { jsx } from "react/jsx-runtime";
+var AppProviderInitialValue = {
+  user: {},
+  company: {},
+  action: {},
+  menu: {},
+  view: {}
+};
+var ReactContext = createContext(AppProviderInitialValue);
+var AppProvider = ({
+  children,
+  menuParams,
+  aid,
+  i18n
+}) => {
+  const { env } = (0, provider_exports.useEnv)();
+  const user = useUser({ service: env.default_service, i18n });
+  const company = useCompany({ service: env.default_service });
+  const menuContext = useMemo4(() => {
+    return (0, utils_exports.combineContexts)([
+      {
+        ...user?.context,
+        ...!isObjectEmpty(env?.user) ? { lang: env?.context?.lang } : {},
+        ...menuParams?.context ?? {}
+      }
+    ]);
+  }, [user?.context, company?.companyInfo?.isFetched, env?.context?.lang]);
+  const menu = useMenu({
+    context: {
+      ...menuContext
+    },
+    specification: menuParams?.specification,
+    domain: menuParams?.domain,
+    defaultService: env.default_service
+  });
+  const action = useMemo4(() => {
+    return menu?.state?.action;
+  }, [menu?.state?.action, env?.context?.lang]);
+  const viewContext = useMemo4(() => {
+    return (0, utils_exports.combineContexts)([
+      menuContext,
+      { ...(0, utils_exports.evalJSONContext)(action?.context) }
+    ]);
+  }, [menuContext, action?.context, env?.context?.lang]);
+  const view = useViewV2({
+    action,
+    context: viewContext,
+    aid,
+    service: menu?.service,
+    xNode: menu?.xNode
+  });
+  return /* @__PURE__ */ jsx(
+    ReactContext.Provider,
+    {
+      value: {
+        user,
+        company,
+        menu,
+        action,
+        view
+      },
+      children
+    }
+  );
+};
+var useAppProvider = () => {
+  const context = useContext(ReactContext);
+  if (!context) {
+    return AppProviderInitialValue;
+  }
+  return context;
+};
+
+// src/hooks/core/use-config.ts
+import { useEffect as useEffect5 } from "react";
+var useConfig = ({
+  envConfig,
+  config,
+  localStorageUtils,
+  sessionStorageUtils: sessionStorageUtils2
+}) => {
+  const { setupEnv, setEnvFile } = (0, provider_exports.useEnv)();
+  useEffect5(() => {
+    try {
+      setupEnv({
+        baseUrl: envConfig.baseUrl,
+        config: envConfig.config,
+        default_service: "",
+        localStorageUtils: localStorageUtils && localStorageUtils(),
+        sessionStorageUtils: localStorageUtils && sessionStorageUtils2()
+      });
+      setEnvFile(config);
+    } catch (error) {
+      console.error("Error loading env or config:", error);
+    }
+  }, [envConfig, config]);
+  return { envConfig, config };
+};
+
+// src/hooks/core/use-get-action.ts
+var useGetAction = ({
+  aid,
+  context
+}) => {
+  const { useLoadAction: useLoadAction2, useRunAction: useRunAction2 } = (0, provider_exports.useService)();
+  const queryLoadAction = useLoadAction2();
+  const queryRunAction = useRunAction2();
+  const handleActionResult = (data) => {
+    if (data && data.result && data.result.views && Array.isArray(data.result.views) && data.result.views.length > 0) {
+    }
+  };
+  const onLoadAction = () => {
+    queryLoadAction.mutate(
+      {
+        idAction: aid,
+        context
+      },
+      {
+        onSuccess: (data) => {
+          if (data?.result?.type === "ir.actions.act_window") {
+            handleActionResult(data);
+          } else if (data?.result?.type === "ir.actions.server") {
+            queryRunAction.mutate(
+              {
+                idAction: aid,
+                context
+              },
+              {
+                onSuccess: handleActionResult
+              }
+            );
+          }
+        }
+      }
+    );
+  };
+  return {
+    onLoadAction
+  };
+};
+
+// src/hooks/core/use-get-specification.ts
+import { useMemo as useMemo5 } from "react";
+var useGetSpecification = ({
+  model,
+  viewData,
+  fields
+}) => {
+  const baseModel = useMemo5(
+    () => ({
+      name: String(model),
+      view: viewData,
+      fields
+    }),
+    [model, viewData, fields]
+  );
+  const initModel = useModel();
+  const modelInstance = useMemo5(() => {
+    if (viewData) {
+      return initModel.initModel(baseModel);
+    }
+    return null;
+  }, [baseModel, viewData, model]);
+  const specification = useMemo5(() => {
+    if (modelInstance) {
+      return modelInstance.getSpecification();
+    }
+    return null;
+  }, [modelInstance, model]);
+  return { specification };
+};
+
+// src/hooks/core/use-list-data.ts
+import { useMemo as useMemo6, useState as useState5 } from "react";
+
+// src/hooks/utils/use-debounce.ts
+import { useEffect as useEffect6, useState as useState3 } from "react";
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState3(value);
+  useEffect6(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return [debouncedValue];
+}
+
+// src/hooks/utils/use-get-rowids.ts
+import { useCallback as useCallback3, useEffect as useEffect7, useRef, useState as useState4 } from "react";
+var useGetRowIds = (tableRef) => {
+  function isElementVisible(el) {
+    const style = window.getComputedStyle(el);
+    return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+  }
+  function arraysAreEqual(a, b) {
+    if (a.length !== b.length) return false;
+    if (a.length === 0 && b.length === 0) return true;
+    const setA = new Set(a);
+    const setB = new Set(b);
+    if (setA.size !== setB.size) return false;
+    for (const val of setA) {
+      if (!setB.has(val)) return false;
+    }
+    return true;
+  }
+  const [rowIds, setRowIds] = useState4([]);
+  const lastRowIdsRef = useRef([]);
+  const updateVisibleRowIds = useCallback3(() => {
+    const table = tableRef.current;
+    if (!table) return;
+    const rows = table.querySelectorAll("tr[data-row-id]");
+    const ids = [];
+    rows.forEach((row) => {
+      const el = row;
+      if (isElementVisible(el)) {
+        const id = el.getAttribute("data-row-id");
+        if (id) ids.push(id);
+      }
+    });
+    const uniqueIds = Array.from(new Set(ids));
+    if (!arraysAreEqual(lastRowIdsRef.current, uniqueIds)) {
+      lastRowIdsRef.current = uniqueIds;
+      setRowIds(uniqueIds);
+    }
+  }, [tableRef]);
+  useEffect7(() => {
+    const table = tableRef.current;
+    if (!table) return;
+    const mutationObserver = new MutationObserver(() => {
+      updateVisibleRowIds();
+    });
+    mutationObserver.observe(table, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["style", "class"]
+    });
+    const resizeObserver = new ResizeObserver(() => {
+      updateVisibleRowIds();
+    });
+    resizeObserver.observe(table);
+    const handleScroll = () => updateVisibleRowIds();
+    table.addEventListener("scroll", handleScroll, true);
+    updateVisibleRowIds();
+    return () => {
+      mutationObserver.disconnect();
+      resizeObserver.disconnect();
+      table.removeEventListener("scroll", handleScroll, true);
+    };
+  }, [updateVisibleRowIds, tableRef?.current]);
+  return { rowIds, refresh: updateVisibleRowIds };
+};
+
+// src/hooks/core/use-list-data.ts
+var useListData = ({
+  action,
+  context,
+  viewData,
+  model,
+  service,
+  xNode,
+  mode,
+  limit = 10
+}) => {
+  const { useGetListData: useGetListData2 } = (0, provider_exports.useService)();
+  const [page, setPage] = useState5(0);
+  const [pageLimit, setPageLimit] = useState5(limit);
+  const [groupByList, setGroupByList] = useState5(null);
+  const [domain, setDomain] = useState5(null);
+  const [order, setOrder] = useState5("");
+  const [selectedRowKeys, setSelectedRowKeys] = useState5([]);
+  const [debouncedPage] = useDebounce(page, 500);
+  const [debouncedDomain] = useDebounce(domain, 500);
+  const { specification } = useGetSpecification({
+    model,
+    viewData,
+    fields: mode === "kanban" ? viewData?.views?.kanban?.fields : viewData?.views?.list?.fields
+  });
+  const listDataProps = useMemo6(() => {
+    if (!viewData || !action || !context) {
+      return null;
+    }
+    const domainParse = domain ? [...domain] : action?.domain ? Array.isArray(action?.domain) ? [...action?.domain] : (0, utils_exports.evalJSONDomain)(action?.domain, context) : [];
+    const limit2 = pageLimit;
+    const offset = debouncedPage * pageLimit;
+    const fields = typeof groupByList === "object" ? groupByList?.fields : void 0;
+    const groupby = typeof groupByList === "object" ? [groupByList?.contexts?.[0]?.group_by] : [];
+    const sort = order ?? (0, utils_exports.formatSortingString)(
+      (mode === "kanban" ? viewData?.views?.kanban : viewData?.views?.list)?.default_order
+    ) ?? "";
+    return {
+      model: action?.res_model,
+      specification,
+      domain: domainParse,
+      limit: limit2,
+      offset,
+      fields,
+      groupby,
+      context,
+      sort,
+      mode
+    };
+  }, [
+    action,
+    groupByList,
+    order,
+    debouncedPage,
+    pageLimit,
+    debouncedDomain,
+    context,
+    model
+  ]);
+  const list = useGetListData2(
+    { ...listDataProps },
+    [
+      listDataProps?.domain,
+      listDataProps?.groupby,
+      listDataProps?.limit,
+      listDataProps?.offset,
+      listDataProps?.sort,
+      listDataProps?.context,
+      listDataProps?.specification,
+      listDataProps?.mode
+    ],
+    !!listDataProps && !!specification && !isObjectEmpty(specification) && !!domain,
+    service,
+    xNode
+  );
+  return {
+    ...list,
+    state: {
+      specification,
+      page,
+      order,
+      domain: listDataProps?.domain,
+      pageLimit,
+      groupByList,
+      selectedRowKeys,
+      setPage,
+      setOrder,
+      setDomain,
+      setPageLimit,
+      setGroupByList,
+      setSelectedRowKeys
+    }
+  };
+};
+export {
+  AppProvider,
+  useAddEntity,
+  useAppProvider,
+  useButton,
+  useCallAction,
+  useChangeOrderPreparationState,
+  useChangeStatus,
+  useCheckPayment,
+  useCompany,
+  useConfig,
+  useCreateEntity,
+  useCreatePosConfig,
+  useCreateSession,
+  useDebounce,
+  useDelete,
+  useDeleteComment,
+  useDeleteEntity,
+  useDetail,
+  useDuplicateRecord,
+  useExecuteImport,
+  useExportExcel,
+  useForgotPassword,
+  useForgotPasswordSSO,
+  useGenSerialNumber,
+  useGeneratePaymentQrInfo,
+  useGet2FAMethods,
+  useGetASession,
+  useGetAccessByCode,
+  useGetAction,
+  useGetActionDetail,
+  useGetAll,
+  useGetCalendar,
+  useGetComment,
+  useGetCompanyInfo,
+  useGetConversionRate,
+  useGetCurrency,
+  useGetCurrentCompany,
+  useGetDetail,
+  useGetExternalTabs,
+  useGetFieldExport,
+  useGetFieldOnChange,
+  useGetFileExcel,
+  useGetFormView,
+  useGetGroups,
+  useGetList,
+  useGetListCompany,
+  useGetListData,
+  useGetListMyBankAccount,
+  useGetMenu,
+  useGetOrderLine,
+  useGetPinCode,
+  useGetPrintReport,
+  useGetProGressBar,
+  useGetProfile,
+  useGetProvider,
+  useGetResequence,
+  useGetRowIds,
+  useGetSelection,
+  useGetSpecification,
+  useGetUser,
+  useGetView,
+  useGrantAccess,
+  useIsValidToken,
+  useListData,
+  useLoadAction,
+  useLoadMessage,
+  useLoginCredential,
+  useLoginSocial,
+  useLogout,
+  useMenu,
+  useModel,
+  useOdooDataTransform,
+  useOnChangeForm,
+  useParsePreview,
+  usePrint,
+  useProfile,
+  useReadGroup,
+  useRemoveRow,
+  useRemoveTotpSetup,
+  useRequestSetupTotp,
+  useResetPassword,
+  useResetPasswordSSO,
+  useRunAction,
+  useSave,
+  useSendComment,
+  useSettingsWebRead2fa,
+  useSignInSSO,
+  useSwitchLocale,
+  useUpdatePassword,
+  useUploadFile,
+  useUploadFileExcel,
+  useUploadIdFile,
+  useUploadImage,
+  useUser,
+  useValidateActionToken,
+  useVerify2FA,
+  useVerifyTotp,
+  useViewV2
+};