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

package/dist/hooks.js

@@ -0,0 +1,977 @@
+"use strict";
+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"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  AppProvider: () => AppProvider,
+  useAddEntity: () => import_hooks2.useAddEntity,
+  useAppProvider: () => useAppProvider,
+  useButton: () => import_hooks2.useButton,
+  useCallAction: () => useCallAction,
+  useChangeOrderPreparationState: () => import_hooks2.useChangeOrderPreparationState,
+  useChangeStatus: () => import_hooks2.useChangeStatus,
+  useCheckPayment: () => import_hooks2.useCheckPayment,
+  useCompany: () => useCompany,
+  useConfig: () => useConfig,
+  useCreateEntity: () => import_hooks2.useCreateEntity,
+  useCreatePosConfig: () => import_hooks2.useCreatePosConfig,
+  useCreateSession: () => import_hooks2.useCreateSession,
+  useDebounce: () => useDebounce,
+  useDelete: () => import_hooks2.useDelete,
+  useDeleteComment: () => import_hooks2.useDeleteComment,
+  useDeleteEntity: () => import_hooks2.useDeleteEntity,
+  useDetail: () => useDetail,
+  useDuplicateRecord: () => import_hooks2.useDuplicateRecord,
+  useExecuteImport: () => import_hooks2.useExecuteImport,
+  useExportExcel: () => import_hooks2.useExportExcel,
+  useForgotPassword: () => import_hooks2.useForgotPassword,
+  useForgotPasswordSSO: () => import_hooks2.useForgotPasswordSSO,
+  useGenSerialNumber: () => import_hooks2.useGenSerialNumber,
+  useGeneratePaymentQrInfo: () => import_hooks2.useGeneratePaymentQrInfo,
+  useGet2FAMethods: () => import_hooks2.useGet2FAMethods,
+  useGetASession: () => import_hooks2.useGetASession,
+  useGetAccessByCode: () => import_hooks2.useGetAccessByCode,
+  useGetAction: () => useGetAction,
+  useGetActionDetail: () => import_hooks2.useGetActionDetail,
+  useGetAll: () => import_hooks2.useGetAll,
+  useGetCalendar: () => import_hooks2.useGetCalendar,
+  useGetComment: () => import_hooks2.useGetComment,
+  useGetCompanyInfo: () => import_hooks2.useGetCompanyInfo,
+  useGetConversionRate: () => import_hooks2.useGetConversionRate,
+  useGetCurrency: () => import_hooks2.useGetCurrency,
+  useGetCurrentCompany: () => import_hooks2.useGetCurrentCompany,
+  useGetDetail: () => import_hooks2.useGetDetail,
+  useGetExternalTabs: () => import_hooks2.useGetExternalTabs,
+  useGetFieldExport: () => import_hooks2.useGetFieldExport,
+  useGetFieldOnChange: () => import_hooks2.useGetFieldOnChange,
+  useGetFileExcel: () => import_hooks2.useGetFileExcel,
+  useGetFormView: () => import_hooks2.useGetFormView,
+  useGetGroups: () => import_hooks2.useGetGroups,
+  useGetList: () => import_hooks2.useGetList,
+  useGetListCompany: () => import_hooks2.useGetListCompany,
+  useGetListData: () => import_hooks2.useGetListData,
+  useGetListMyBankAccount: () => import_hooks2.useGetListMyBankAccount,
+  useGetMenu: () => import_hooks2.useGetMenu,
+  useGetOrderLine: () => import_hooks2.useGetOrderLine,
+  useGetPinCode: () => import_hooks2.useGetPinCode,
+  useGetPrintReport: () => import_hooks2.useGetPrintReport,
+  useGetProGressBar: () => import_hooks2.useGetProGressBar,
+  useGetProfile: () => import_hooks2.useGetProfile,
+  useGetProvider: () => import_hooks2.useGetProvider,
+  useGetResequence: () => import_hooks2.useGetResequence,
+  useGetRowIds: () => useGetRowIds,
+  useGetSelection: () => import_hooks2.useGetSelection,
+  useGetSpecification: () => useGetSpecification,
+  useGetUser: () => import_hooks2.useGetUser,
+  useGetView: () => import_hooks2.useGetView,
+  useGrantAccess: () => import_hooks2.useGrantAccess,
+  useIsValidToken: () => import_hooks2.useIsValidToken,
+  useListData: () => useListData,
+  useLoadAction: () => import_hooks2.useLoadAction,
+  useLoadMessage: () => import_hooks2.useLoadMessage,
+  useLoginCredential: () => import_hooks2.useLoginCredential,
+  useLoginSocial: () => import_hooks2.useLoginSocial,
+  useLogout: () => import_hooks2.useLogout,
+  useMenu: () => useMenu,
+  useModel: () => import_hooks2.useModel,
+  useOdooDataTransform: () => import_hooks2.useOdooDataTransform,
+  useOnChangeForm: () => import_hooks2.useOnChangeForm,
+  useParsePreview: () => import_hooks2.useParsePreview,
+  usePrint: () => import_hooks2.usePrint,
+  useProfile: () => useProfile,
+  useReadGroup: () => import_hooks2.useReadGroup,
+  useRemoveRow: () => import_hooks2.useRemoveRow,
+  useRemoveTotpSetup: () => import_hooks2.useRemoveTotpSetup,
+  useRequestSetupTotp: () => import_hooks2.useRequestSetupTotp,
+  useResetPassword: () => import_hooks2.useResetPassword,
+  useResetPasswordSSO: () => import_hooks2.useResetPasswordSSO,
+  useRunAction: () => import_hooks2.useRunAction,
+  useSave: () => import_hooks2.useSave,
+  useSendComment: () => import_hooks2.useSendComment,
+  useSettingsWebRead2fa: () => import_hooks2.useSettingsWebRead2fa,
+  useSignInSSO: () => import_hooks2.useSignInSSO,
+  useSwitchLocale: () => import_hooks2.useSwitchLocale,
+  useUpdatePassword: () => import_hooks2.useUpdatePassword,
+  useUploadFile: () => import_hooks2.useUploadFile,
+  useUploadFileExcel: () => import_hooks2.useUploadFileExcel,
+  useUploadIdFile: () => import_hooks2.useUploadIdFile,
+  useUploadImage: () => import_hooks2.useUploadImage,
+  useUser: () => useUser,
+  useValidateActionToken: () => import_hooks2.useValidateActionToken,
+  useVerify2FA: () => import_hooks2.useVerify2FA,
+  useVerifyTotp: () => import_hooks2.useVerifyTotp,
+  useViewV2: () => useViewV2
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_hooks2 = require("@fctc/interface-logic/hooks");
+
+// src/hooks/core/use-app-provider.tsx
+var import_react8 = require("react");
+
+// src/hooks/core/use-menu.ts
+var import_react3 = require("react");
+
+// src/hooks/core/use-call-action.ts
+var import_react = require("react");
+
+// src/provider.ts
+var provider_exports = {};
+__reExport(provider_exports, require("@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] = (0, import_react.useState)(
+    void 0
+  );
+  const callAction = (0, import_react.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
+var import_react2 = require("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 (0, import_react2.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();
+  (0, import_react2.useEffect)(() => {
+    try {
+      const storedValue = localStorage.getItem(key);
+      setState(storedValue);
+    } catch (e) {
+      console.error("Local storage is unavailable:", e);
+    }
+  }, [key]);
+  const setValue = (0, import_react2.useCallback)(
+    (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, require("@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] = (0, import_react3.useState)("");
+  const [xNode, setXNode] = (0, import_react3.useState)("");
+  const menuData = useGetMenu2(
+    context,
+    specification,
+    !!context && !isObjectEmpty(context) && !!context?.uid && !!context?.lang,
+    domain,
+    defaultService
+  );
+  const [menuId, setMenuId] = (0, import_react3.useState)(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
+var import_react_query = require("@tanstack/react-query");
+var import_react4 = require("react");
+var useDetail = (sub) => {
+  const { setUserInfo, env } = (0, provider_exports.useEnv)();
+  const { useGetDetail: useGetDetail2 } = (0, provider_exports.useService)();
+  const fetchGetDetail = useGetDetail2();
+  const userDetailQuery = (0, import_react_query.useQuery)({
+    queryKey: ["userDetailQuery", sub],
+    queryFn: () => {
+      return fetchGetDetail.mutateAsync({
+        model: "res.users",
+        ids: [sub],
+        specification: { image_256: {} },
+        service: env?.default_service
+      });
+    },
+    enabled: !!sub
+  });
+  (0, import_react4.useEffect)(() => {
+    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
+var import_react_query2 = require("@tanstack/react-query");
+var import_react5 = require("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 = (0, import_react_query2.useQuery)({
+    queryKey: ["userInfo"],
+    queryFn: () => getProfile.mutateAsync(),
+    enabled: isObjectEmpty(env?.user)
+  });
+  (0, import_react5.useEffect)(() => {
+    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 = (0, import_react5.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
+var import_react6 = require("react");
+var useViewV2 = ({
+  action,
+  context,
+  aid,
+  service,
+  xNode
+}) => {
+  const { useGetView: useGetView2 } = (0, provider_exports.useService)();
+  const viewParams = (0, import_react6.useMemo)(() => {
+    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
+var import_react_query3 = require("@tanstack/react-query");
+var import_react7 = require("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 = (0, import_react_query3.useQuery)({
+    queryKey: ["currentCompany"],
+    queryFn: fetchCurrentCompany,
+    enabled: !!env?.defaultCompany
+  });
+  const current_company_id = (0, import_react7.useMemo)(() => {
+    return currentCompany.data?.current_company_id;
+  }, [currentCompany.data]);
+  (0, import_react7.useEffect)(() => {
+    if (current_company_id) {
+      const companyIDs = [current_company_id];
+      setCompanies(companyIDs);
+    }
+  }, [current_company_id]);
+  const getCompanyInfo = useGetCompanyInfo2();
+  const companyInfo = (0, import_react_query3.useQuery)({
+    queryKey: ["companyInfoQuery", current_company_id],
+    queryFn: () => getCompanyInfo.mutateAsync({
+      service,
+      id: Number(current_company_id)
+    }),
+    enabled: !!current_company_id
+  });
+  (0, import_react7.useEffect)(() => {
+    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
+var import_jsx_runtime = require("react/jsx-runtime");
+var AppProviderInitialValue = {
+  user: {},
+  company: {},
+  action: {},
+  menu: {},
+  view: {}
+};
+var ReactContext = (0, import_react8.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 = (0, import_react8.useMemo)(() => {
+    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 = (0, import_react8.useMemo)(() => {
+    return menu?.state?.action;
+  }, [menu?.state?.action, env?.context?.lang]);
+  const viewContext = (0, import_react8.useMemo)(() => {
+    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__ */ (0, import_jsx_runtime.jsx)(
+    ReactContext.Provider,
+    {
+      value: {
+        user,
+        company,
+        menu,
+        action,
+        view
+      },
+      children
+    }
+  );
+};
+var useAppProvider = () => {
+  const context = (0, import_react8.useContext)(ReactContext);
+  if (!context) {
+    return AppProviderInitialValue;
+  }
+  return context;
+};
+
+// src/hooks/core/use-config.ts
+var import_react9 = require("react");
+var useConfig = ({
+  envConfig,
+  config,
+  localStorageUtils,
+  sessionStorageUtils: sessionStorageUtils2
+}) => {
+  const { setupEnv, setEnvFile } = (0, provider_exports.useEnv)();
+  (0, import_react9.useEffect)(() => {
+    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
+var import_react10 = require("react");
+var useGetSpecification = ({
+  model,
+  viewData,
+  fields
+}) => {
+  const baseModel = (0, import_react10.useMemo)(
+    () => ({
+      name: String(model),
+      view: viewData,
+      fields
+    }),
+    [model, viewData, fields]
+  );
+  const initModel = (0, import_hooks2.useModel)();
+  const modelInstance = (0, import_react10.useMemo)(() => {
+    if (viewData) {
+      return initModel.initModel(baseModel);
+    }
+    return null;
+  }, [baseModel, viewData, model]);
+  const specification = (0, import_react10.useMemo)(() => {
+    if (modelInstance) {
+      return modelInstance.getSpecification();
+    }
+    return null;
+  }, [modelInstance, model]);
+  return { specification };
+};
+
+// src/hooks/core/use-list-data.ts
+var import_react13 = require("react");
+
+// src/hooks/utils/use-debounce.ts
+var import_react11 = require("react");
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = (0, import_react11.useState)(value);
+  (0, import_react11.useEffect)(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return [debouncedValue];
+}
+
+// src/hooks/utils/use-get-rowids.ts
+var import_react12 = require("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] = (0, import_react12.useState)([]);
+  const lastRowIdsRef = (0, import_react12.useRef)([]);
+  const updateVisibleRowIds = (0, import_react12.useCallback)(() => {
+    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]);
+  (0, import_react12.useEffect)(() => {
+    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] = (0, import_react13.useState)(0);
+  const [pageLimit, setPageLimit] = (0, import_react13.useState)(limit);
+  const [groupByList, setGroupByList] = (0, import_react13.useState)(null);
+  const [domain, setDomain] = (0, import_react13.useState)(null);
+  const [order, setOrder] = (0, import_react13.useState)("");
+  const [selectedRowKeys, setSelectedRowKeys] = (0, import_react13.useState)([]);
+  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 = (0, import_react13.useMemo)(() => {
+    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
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});