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

package/dist/widget.mjs

@@ -0,0 +1,2164 @@
+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/widget/basic/status-dropdown-field/controller.ts
+import { useEffect as useEffect8, useRef as useRef2, useState as useState6 } from "react";
+
+// src/environment.ts
+var environment_exports = {};
+__reExport(environment_exports, environment_star);
+import * as environment_star from "@fctc/interface-logic/environment";
+
+// 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/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" }
+];
+var isBlobUrl = (url) => url.startsWith("blob:");
+
+// 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-detail.ts
+import { useQuery } from "@tanstack/react-query";
+import { useEffect as useEffect2 } from "react";
+
+// src/hooks/core/use-profile.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { useEffect as useEffect3, useMemo } from "react";
+
+// src/hooks/core/use-view-v2.ts
+import { useMemo as useMemo2 } from "react";
+
+// src/hooks/core/use-company.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { useEffect as useEffect4, useMemo as useMemo3 } from "react";
+
+// 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 useAppProvider = () => {
+  const context = useContext(ReactContext);
+  if (!context) {
+    return AppProviderInitialValue;
+  }
+  return context;
+};
+
+// src/hooks/core/use-config.ts
+import { useEffect as useEffect5 } from "react";
+
+// 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
+    }
+  };
+};
+
+// src/widget/basic/status-dropdown-field/controller.ts
+var statusDropdownController = (props) => {
+  const { selection, isForm, id, model, name, state, onRefetch } = props;
+  const env = (0, environment_exports.getEnv)();
+  const colors = {
+    normal: "bg-[#e9ecef]",
+    done: "bg-primary",
+    blocked: "bg-red-500"
+  };
+  const [isOpen, setIsOpen] = useState6(false);
+  const buttonRef = useRef2(null);
+  useEffect8(() => {
+    const handleClickOutside = (event) => {
+      if (buttonRef.current && !buttonRef.current.contains(event.target)) {
+        setIsOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, []);
+  const { mutate: onSave } = useSave();
+  const handleClick = async (status) => {
+    setIsOpen(!isOpen);
+    onSave(
+      {
+        ids: id ? [id] : [],
+        model: model ?? "",
+        data: { [name ?? ""]: status },
+        context: env.context
+      },
+      {
+        onSuccess: () => {
+          onRefetch && onRefetch();
+        }
+      }
+    );
+  };
+  return {
+    handleClick,
+    buttonRef,
+    isForm,
+    setIsOpen,
+    isOpen,
+    selection,
+    state,
+    colors
+  };
+};
+
+// src/widget/basic/many2one-field/controller.ts
+import { useCallback as useCallback4, useEffect as useEffect9, useMemo as useMemo7, useState as useState7 } from "react";
+var MANY2ONE_EXTERNAL = "many2one_external";
+var many2oneFieldController = (props) => {
+  const {
+    methods,
+    relation,
+    domain,
+    formValues,
+    value: propValue,
+    onChange,
+    name,
+    context: fieldContext,
+    options: fieldOptions,
+    showDetail,
+    service,
+    xNode,
+    isForm,
+    widget,
+    in_list_view,
+    isEditTable
+  } = props;
+  const { env } = (0, provider_exports.useEnv)();
+  const { action } = useAppProvider();
+  const { useGetSelection: useGetSelection2, useGetDetail: useGetDetail2 } = (0, provider_exports.useService)();
+  const [listOptions, setListOptions] = useState7([]);
+  const [inputValue, setInputValue] = useState7("");
+  const [debouncedInputValue] = useDebounce(inputValue, 1e3);
+  const [isShowModalMany2Many, setIsShowModalMany2Many] = useState7(false);
+  const [tempSelectedOption, setTempSelectedOption] = useState7(null);
+  const [domainModal, setDomainModal] = useState7(null);
+  const [domainObject, setDomainObject] = useState7(null);
+  const initValue = methods?.getValues(name);
+  const contextObject = {
+    ...(typeof action?.context === "string" ? (0, utils_exports.evalJSONContext)(action?.context) : action?.context) || {},
+    ...fieldContext,
+    ...env?.context
+  };
+  const optionsObject = typeof fieldOptions === "string" ? (0, utils_exports.evalJSONContext)(fieldOptions, {
+    ...formValues,
+    ...contextObject,
+    context: contextObject,
+    parent: { ...formValues }
+  }) : fieldOptions;
+  const fetchGetDetail = useGetDetail2();
+  const data = {
+    model: widget === MANY2ONE_EXTERNAL ? optionsObject?.model : relation,
+    domain: widget === MANY2ONE_EXTERNAL ? optionsObject?.domain : domainObject,
+    context: {
+      ...contextObject,
+      ...optionsObject?.context
+    },
+    specification: widget === MANY2ONE_EXTERNAL ? optionsObject?.specification : {
+      id: {},
+      name: {},
+      display_name: {}
+    }
+  };
+  const {
+    data: dataOfSelection,
+    refetch,
+    isFetching
+  } = useGetSelection2({
+    data,
+    queryKey: [`data_${relation}`, domainObject],
+    enabled: false,
+    service: widget === MANY2ONE_EXTERNAL ? optionsObject?.service : service,
+    xNode
+  });
+  const selectOptions = useMemo7(() => {
+    return dataOfSelection?.records?.map((val) => ({
+      value: val?.id,
+      label: val?.display_name || val?.name,
+      ...widget === MANY2ONE_EXTERNAL ? val : {}
+    })) || [];
+  }, [dataOfSelection]);
+  useEffect9(() => {
+    setListOptions(selectOptions);
+    setDomainModal(domainObject);
+  }, [selectOptions]);
+  const parsedFormValues = useMemo7(
+    () => JSON.parse(
+      JSON.stringify({
+        ...formValues,
+        ...contextObject,
+        context: contextObject
+      })
+    ) ?? {},
+    [formValues, contextObject]
+  );
+  useEffect9(() => {
+    const newDomain = (0, utils_exports.evalJSONDomain)(domain, parsedFormValues);
+    const parsedDomain = typeof newDomain === "string" ? JSON.parse(
+      newDomain.replace(/\(/g, "[").replace(/\)/g, "]").replace(/'/g, '"')
+    ) : newDomain;
+    setDomainObject((prev) => {
+      const prevStr = JSON.stringify(prev);
+      const nextStr = JSON.stringify(parsedDomain);
+      return prevStr === nextStr ? prev : parsedDomain;
+    });
+  }, [domain, parsedFormValues]);
+  useEffect9(() => {
+    if (!propValue && tempSelectedOption) {
+      methods?.setValue(name, null, { shouldDirty: true });
+      setTempSelectedOption(null);
+    } else if (propValue) {
+      if (isForm && !isEditTable && optionsObject?.service && optionsObject?.model && !propValue?.display_name && !in_list_view) {
+        fetchGetDetail.mutate(
+          {
+            model: optionsObject?.model,
+            ids: propValue?.id ?? propValue,
+            specification: widget === MANY2ONE_EXTERNAL ? optionsObject?.specification : {
+              id: {},
+              display_name: {}
+            },
+            context: { ...env.context },
+            service: optionsObject ? optionsObject?.service : service,
+            xNode
+          },
+          {
+            onSuccess: (dataResponse) => {
+              const detailData = dataResponse?.[0];
+              setTempSelectedOption({
+                value: detailData?.id,
+                label: detailData?.display_name
+              });
+              if (widget === MANY2ONE_EXTERNAL && optionsObject?.values_included) {
+                Object.keys(optionsObject?.values_included)?.forEach(
+                  (field) => {
+                    methods?.setValue(
+                      optionsObject?.values_included[field]?.name,
+                      detailData?.[field]
+                    );
+                  }
+                );
+                methods?.setValue(name, detailData);
+              }
+            },
+            onError: (error) => {
+              console.log("error", error);
+            }
+          }
+        );
+        return;
+      }
+      setTempSelectedOption({
+        value: propValue?.id,
+        label: propValue?.display_name
+      });
+    }
+  }, [propValue]);
+  const fetchMoreOptions = useCallback4(() => {
+    refetch();
+  }, [refetch]);
+  useEffect9(() => {
+    if (debouncedInputValue) {
+      const filteredDomain = [...domainObject ?? []]?.filter(
+        (d) => !(Array.isArray(d) && d[0] === "name" && d[1] === "ilike")
+      ) || [];
+      const newDomain = [
+        ...filteredDomain,
+        ...debouncedInputValue ? [["name", "ilike", debouncedInputValue]] : []
+      ];
+      setDomainObject(newDomain);
+      setTimeout(() => {
+        fetchMoreOptions();
+      }, 50);
+    }
+  }, [debouncedInputValue]);
+  const handleChooseRecord = useCallback4(
+    (idRecord) => {
+      const newOption = listOptions?.find(
+        (option) => option.value === idRecord
+      );
+      const newValue = widget === MANY2ONE_EXTERNAL && optionsObject?.field_name ? newOption?.[optionsObject?.field_name] : newOption.value;
+      if (widget === MANY2ONE_EXTERNAL && optionsObject?.values_included) {
+        Object.keys(optionsObject?.values_included)?.forEach((field) => {
+          methods?.setValue(
+            optionsObject?.values_included[field]?.name,
+            newOption?.[field],
+            { shouldDirty: true }
+          );
+        });
+      }
+      if (newOption) {
+        methods?.setValue(
+          name,
+          {
+            ...newOption,
+            id: newValue,
+            display_name: newOption?.label
+          },
+          { shouldDirty: true }
+        );
+        setTempSelectedOption(newOption);
+        onChange && onChange(String(name), {
+          ...newOption,
+          id: newValue,
+          display_name: newOption?.label
+        });
+        methods.trigger(name);
+      }
+      setIsShowModalMany2Many(false);
+    },
+    [listOptions, methods, name, onChange]
+  );
+  const handleClose = useCallback4(() => setIsShowModalMany2Many(false), []);
+  const handleSelectChange = useCallback4(
+    (selectedOption) => {
+      if (!selectedOption) {
+        if (widget === MANY2ONE_EXTERNAL && optionsObject?.values_included) {
+          Object.keys(optionsObject?.values_included)?.forEach((field) => {
+            methods?.setValue(
+              optionsObject?.values_included[field]?.name,
+              null,
+              { shouldDirty: true }
+            );
+          });
+        }
+        methods.setValue(name, null, { shouldDirty: true });
+        setTempSelectedOption(null);
+        onChange && onChange(String(name), null);
+        methods.trigger(name);
+        return;
+      }
+      const newValue = widget === MANY2ONE_EXTERNAL && optionsObject?.field_name ? selectedOption?.[optionsObject?.field_name] : selectedOption.value;
+      if (widget === MANY2ONE_EXTERNAL && optionsObject?.values_included) {
+        Object.keys(optionsObject?.values_included)?.forEach((field) => {
+          methods?.setValue(
+            optionsObject?.values_included[field]?.name,
+            selectedOption?.[field],
+            { shouldDirty: true }
+          );
+        });
+      }
+      methods?.setValue(
+        name,
+        {
+          id: newValue,
+          display_name: selectedOption?.label
+        },
+        { shouldDirty: true }
+      );
+      setTempSelectedOption(selectedOption);
+      onChange && onChange(String(name), {
+        id: newValue,
+        display_name: selectedOption.label
+      });
+      methods.trigger(name);
+    },
+    [methods, name, onChange]
+  );
+  const allowShowDetail = showDetail && contextObject?.form_view_ref && (!optionsObject || !("no_open" in optionsObject) || optionsObject.no_open === false);
+  return {
+    isShowModalMany2Many,
+    isFetching,
+    initValue,
+    handleChooseRecord,
+    handleClose,
+    handleSelectChange,
+    domainModal,
+    setInputValue,
+    allowShowDetail,
+    contextObject: {
+      ...contextObject,
+      ...optionsObject?.context
+    },
+    tempSelectedOption,
+    listOptions,
+    fetchMoreOptions,
+    domainObject: widget === MANY2ONE_EXTERNAL ? optionsObject?.domain : domainObject,
+    setIsShowModalMany2Many,
+    setDomainObject,
+    options: optionsObject,
+    relation: widget === MANY2ONE_EXTERNAL ? optionsObject?.model : relation,
+    service: widget === MANY2ONE_EXTERNAL ? optionsObject?.service : service
+  };
+};
+
+// src/widget/basic/many2one-button-field/controller.ts
+var many2oneButtonController = (props) => {
+  const { domain, methods, relation, service, xNode } = props;
+  const actionDataString = sessionStorage.getItem("actionData");
+  const env = (0, environment_exports.getEnv)();
+  const domainObject = (0, utils_exports.evalJSONDomain)(domain, methods?.getValues() || {});
+  const actionData = actionDataString && actionDataString !== "undefined" ? JSON.parse(actionDataString) : {};
+  const { data: dataOfSelection } = useGetSelection({
+    data: {
+      model: relation ?? "",
+      domain: domainObject,
+      context: { ...env.context, ...(0, utils_exports.evalJSONContext)(actionData?.context) }
+    },
+    queryKey: [`data_${relation}`, domainObject],
+    service,
+    xNode
+  });
+  const options = dataOfSelection?.records?.map((val) => ({
+    value: val.id,
+    label: val.name
+  })) || [];
+  return {
+    options
+  };
+};
+
+// src/widget/basic/many2many-field/controller.ts
+import { useEffect as useEffect10, useMemo as useMemo8 } from "react";
+var many2manyFieldController = (props) => {
+  const {
+    relation,
+    domain,
+    context,
+    options,
+    enabled: enabledCallAPI,
+    service,
+    validateAndParseDate,
+    moment
+  } = props;
+  const { env } = (0, provider_exports.useEnv)();
+  const { user } = useAppProvider();
+  const { useGetView: useGetView2 } = (0, provider_exports.useService)();
+  const dataUser = user?.userProfile?.data;
+  const contextObject = useMemo8(
+    () => ({
+      ...env.context,
+      ...context || {}
+    }),
+    [env?.context, context]
+  );
+  const viewParams = useMemo8(
+    () => ({
+      model: relation,
+      views: [
+        [false, "list"],
+        [false, "search"]
+      ],
+      context: contextObject,
+      service,
+      xNode: service == "wesap" && dataUser?.x_node
+    }),
+    [relation, contextObject, service, dataUser?.x_node]
+  );
+  const { data: viewResponse } = useGetView2({
+    viewParams,
+    enabled: enabledCallAPI
+  });
+  const default_order = viewResponse && viewResponse?.views?.list?.default_order;
+  const optionsObject = useMemo8(
+    () => (options && typeof options === "string" ? (0, utils_exports.evalJSONContext)(options) : options) || {},
+    [options]
+  );
+  const {
+    data: dataResponse,
+    isFetched,
+    isLoading,
+    state,
+    isPlaceholderData
+  } = useListData({
+    action: {
+      domain,
+      res_model: relation
+    },
+    context: contextObject,
+    model: relation ?? "",
+    viewData: viewResponse,
+    service,
+    xNode: service == "wesap" && dataUser?.x_node
+  });
+  const {
+    selectedRowKeys,
+    groupByList,
+    domain: domainList,
+    page,
+    pageLimit,
+    setDomain,
+    setOrder,
+    setPage,
+    setSelectedRowKeys,
+    setGroupByList,
+    setPageLimit,
+    specification
+  } = state;
+  useEffect10(() => {
+    return () => {
+      setDomain(null);
+      setOrder("");
+      setGroupByList(null);
+      setPageLimit(10);
+    };
+  }, []);
+  const { rows, columns, typeTable, onToggleColumnOptional } = tableController({
+    data: {
+      fields: viewResponse?.views?.list?.fields,
+      records: dataResponse?.records ?? dataResponse?.groups,
+      dataModel: viewResponse?.models?.[String(relation)],
+      context: contextObject,
+      typeTable: dataResponse?.groups ? "group" : "list"
+    }
+  });
+  const searchControllers = searchController({
+    viewData: viewResponse,
+    model: relation ?? "",
+    context: contextObject,
+    domain,
+    fieldsList: [
+      ...columns?.filter(
+        (col) => col?.field?.type_co === "field" && col?.optional !== "hide"
+      )?.map((col) => ({ ...col.field })) ?? []
+    ],
+    validateAndParseDate,
+    moment
+  });
+  return {
+    rows,
+    columns,
+    optionsObject,
+    viewData: viewResponse,
+    totalRows: dataResponse?.length ?? 0,
+    onToggleColumnOptional,
+    typeTable,
+    isLoading,
+    isFetched,
+    isPlaceholderData,
+    page,
+    pageLimit,
+    groupByList,
+    selectedRowKeys,
+    domain: domainList,
+    setPage,
+    setDomain,
+    setPageLimit,
+    setGroupByList,
+    setSelectedRowKeys,
+    searchController: searchControllers,
+    specification
+  };
+};
+
+// src/widget/basic/many2many-tags-field/controller.ts
+import { useCallback as useCallback5, useEffect as useEffect11, useMemo as useMemo9, useState as useState8 } from "react";
+
+// src/constants.ts
+var constants_exports = {};
+__reExport(constants_exports, constants_star);
+import * as constants_star from "@fctc/interface-logic/constants";
+
+// src/widget/basic/many2many-tags-field/controller.ts
+var many2manyTagsController = (props) => {
+  const {
+    relation,
+    domain,
+    options: optionsFields,
+    widget,
+    formValues,
+    service,
+    xNode,
+    context: fieldContext,
+    onChange,
+    methods,
+    name
+  } = props;
+  const isUser = relation === "res.users" || relation === "res.partner";
+  const { env } = (0, provider_exports.useEnv)();
+  const { action } = useAppProvider();
+  const { useGetSelection: useGetSelection2 } = (0, provider_exports.useService)();
+  const [options, setOptions] = useState8([]);
+  const [domainObject, setDomainObject] = useState8(null);
+  const [isShowModalMany2Many, setIsShowModalMany2Many] = useState8(false);
+  const addtionalFields = optionsFields ? (0, utils_exports.evalJSONContext)(optionsFields) : null;
+  const contextObject = {
+    ...(0, utils_exports.evalJSONContext)(action?.context) || {},
+    ...fieldContext ?? {},
+    ...env?.context
+  };
+  const parsedFormValues = useMemo9(
+    () => JSON.parse(
+      JSON.stringify({
+        ...formValues,
+        ...contextObject,
+        context: contextObject,
+        parent: { ...formValues }
+      })
+    ) ?? {},
+    [formValues, contextObject]
+  );
+  useEffect11(() => {
+    const newDomain = (0, utils_exports.evalJSONDomain)(domain, parsedFormValues);
+    setDomainObject(
+      (prev) => JSON.stringify(prev) === JSON.stringify(newDomain) ? prev : newDomain
+    );
+  }, [domain, parsedFormValues]);
+  const data = {
+    model: relation ?? "",
+    domain: domainObject,
+    specification: {
+      id: {},
+      name: {},
+      display_name: {},
+      ...widget && constants_exports.WIDGETAVATAR[widget] ? { image_256: {} } : {},
+      ...widget && constants_exports.WIDGETCOLOR[widget] && addtionalFields?.color_field ? { color: {} } : {}
+    },
+    context: env.context
+  };
+  const queryKey = [`data_${relation}`, domainObject];
+  const {
+    data: dataOfSelection,
+    refetch,
+    isFetching
+  } = useGetSelection2({
+    data,
+    queryKey,
+    service,
+    xNode,
+    enabled: false
+  });
+  const selectOptions = useMemo9(() => {
+    return dataOfSelection?.records?.map((val) => ({
+      value: val.id,
+      label: val.name ?? val.display_name,
+      ...val
+    })) || [];
+  }, [dataOfSelection]);
+  useEffect11(() => {
+    setOptions(selectOptions);
+  }, [selectOptions]);
+  const fetchMoreOptions = useCallback5(() => {
+    refetch();
+  }, [refetch]);
+  const transfer = (data2) => {
+    return data2?.map((val) => ({
+      id: val.value,
+      display_name: val.label
+    })) || [];
+  };
+  const handleChooseRecord = useCallback5(
+    (idRecord) => {
+      const newOption = options.find(
+        (option) => option.value === idRecord
+      );
+      setIsShowModalMany2Many(false);
+    },
+    [options, methods, name, onChange]
+  );
+  const handleClose = useCallback5(() => setIsShowModalMany2Many(false), []);
+  return {
+    options,
+    transfer,
+    isUser,
+    isFetching,
+    fetchMoreOptions,
+    domainObject,
+    setDomainObject,
+    handleChooseRecord,
+    handleClose,
+    isShowModalMany2Many,
+    setIsShowModalMany2Many
+  };
+};
+
+// src/widget/basic/status-bar-field/controller.ts
+import { useState as useState9 } from "react";
+var durationController = (props) => {
+  const { relation, domain, formValues, name, id, model, onRefetch, enabled } = props;
+  const specification = {
+    id: 0,
+    name: "",
+    fold: ""
+  };
+  const { useGetListData: useGetListData2, useChangeStatus: useChangeStatus2 } = (0, provider_exports.useService)();
+  const { env } = (0, provider_exports.useEnv)();
+  const [disabled, setDisabled] = useState9(false);
+  const [modelStatus, setModalStatus] = useState9(false);
+  const queryKey = [`data-status-duration`, specification];
+  const listDataProps = {
+    model: relation,
+    specification,
+    domain: (0, utils_exports.evalJSONDomain)(domain, JSON.parse(JSON.stringify(formValues))),
+    limit: 10,
+    offset: 0,
+    fields: "",
+    groupby: [],
+    context: {
+      lang: env.context.lang
+    },
+    sort: ""
+  };
+  const { data: dataResponse } = useGetListData2(
+    listDataProps,
+    queryKey,
+    enabled
+  );
+  const { mutate: fetchChangeStatus } = useChangeStatus2();
+  const handleClick = async (stage_id) => {
+    setDisabled(true);
+    if (stage_id) {
+      fetchChangeStatus(
+        {
+          data: {
+            stage_id,
+            name,
+            id,
+            model,
+            lang: env.context.lang
+          }
+        },
+        {
+          onSuccess: (res) => {
+            if (res) {
+              setDisabled(false);
+              onRefetch && onRefetch();
+            }
+          }
+        }
+      );
+    }
+  };
+  return {
+    dataResponse,
+    handleClick,
+    disabled,
+    modelStatus,
+    setModalStatus
+  };
+};
+
+// src/widget/basic/priority-field/controller.ts
+var priorityFieldController = (props) => {
+  const { name, model, index, actionData, context, onChange, specification } = props;
+  const _context = { ...(0, utils_exports.evalJSONContext)(actionData?.context) };
+  const contextObject = { ...context, ..._context };
+  const { useSave: useSave2 } = (0, provider_exports.useService)();
+  const { mutateAsync: fetchSave } = useSave2();
+  const savePriorities = async ({
+    value,
+    resetPriority
+  }) => {
+    const priorityValue = value <= 0 ? 0 : value - 1;
+    try {
+      fetchSave({
+        ids: index ? [index] : [],
+        data: { [String(name)]: String(priorityValue) },
+        model: String(model),
+        context: contextObject,
+        specification
+      });
+      if (typeof onChange === "function") {
+        onChange(String(name), String(priorityValue));
+      }
+    } catch (error) {
+      if (resetPriority) {
+        resetPriority();
+      }
+    }
+  };
+  return {
+    savePriorities
+  };
+};
+
+// src/widget/basic/download-file-field/controller.ts
+import { useId, useState as useState10 } from "react";
+var downloadFileController = () => {
+  const inputId = useId();
+  const [file, setFile] = useState10(null);
+  const handleFileChange = (e) => {
+    setFile(e.target.files[0]);
+  };
+  const handleFileDownload = () => {
+    const url = URL.createObjectURL(file);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = file.name;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+  };
+  return {
+    inputId,
+    file,
+    handleFileChange,
+    handleFileDownload
+  };
+};
+
+// src/widget/basic/download-binary-field/controller.ts
+var downLoadBinaryController = (props) => {
+  const { value, defaultValue, formValues } = props;
+  const downloadFile = async (url, filename) => {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) throw new Error(`Failed to fetch ${url}`);
+      const contentType = response.headers.get("Content-Type") || "";
+      let ext = "";
+      if (contentType.includes("pdf")) ext = ".pdf";
+      else if (contentType.includes("png")) ext = ".png";
+      else if (contentType.includes("jpeg") || contentType.includes("jpg"))
+        ext = ".jpg";
+      else if (contentType.includes("zip")) ext = ".zip";
+      else if (contentType.includes("msword")) ext = ".doc";
+      else if (contentType.includes("spreadsheet")) ext = ".xls";
+      else if (contentType.includes("json")) ext = ".json";
+      else if (contentType.includes("text")) ext = ".txt";
+      else {
+        ext = "";
+      }
+      const blob = await response.blob();
+      const urlBlob = window.URL.createObjectURL(blob);
+      const link = document.createElement("a");
+      link.href = urlBlob;
+      link.download = (filename || "file") + ext;
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+      window.URL.revokeObjectURL(urlBlob);
+    } catch (error) {
+      console.error("File download failed:", error);
+    }
+  };
+  const handleFileDownload = async (e) => {
+    e.stopPropagation();
+    await downloadFile(value || defaultValue, formValues?.name);
+  };
+  return {
+    handleFileDownload
+  };
+};
+
+// src/widget/basic/copy-link-button/controller.ts
+import { useState as useState11 } from "react";
+var copyTextToClipboard = async (text) => {
+  if ("clipboard" in navigator) {
+    return await navigator.clipboard.writeText(text);
+  } else {
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    textArea.style.position = "fixed";
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+    try {
+      document.execCommand("copy");
+    } finally {
+      document.body.removeChild(textArea);
+    }
+  }
+};
+var copyLinkButtonController = (props) => {
+  const { value, defaultValue } = props;
+  const [isCopied, setIsCopied] = useState11(false);
+  const handleCopyToClipboard = async (value2) => {
+    await copyTextToClipboard(value2);
+    setIsCopied(true);
+    setTimeout(() => setIsCopied(false), 2e3);
+  };
+  const propValue = value || defaultValue;
+  return {
+    isCopied,
+    handleCopyToClipboard,
+    propValue
+  };
+};
+
+// src/widget/basic/color-field/color-controller.ts
+var colorFieldController = (props) => {
+  const { value, isForm, name, formValues, idForm, model, actionData } = props;
+  const { env } = (0, provider_exports.useEnv)();
+  const { useSave: useSave2 } = (0, provider_exports.useService)();
+  const _context = { ...(0, utils_exports.evalJSONContext)(actionData?.context) || {} };
+  const contextObject = { ...env.context, ..._context };
+  const idDefault = isForm ? idForm : formValues?.id;
+  const { mutate: onSave } = useSave2();
+  const savePickColor = async (colorObject) => {
+    const { id } = colorObject;
+    if (value === id) return;
+    try {
+      onSave({
+        ids: idDefault !== null ? [idDefault] : [],
+        model: String(model),
+        data: { [String(name)]: id },
+        specification: {
+          name: {},
+          color: {}
+        },
+        context: contextObject
+      });
+    } catch (error) {
+      console.log(error);
+    }
+  };
+  return {
+    savePickColor
+  };
+};
+
+// src/widget/basic/binary-field/controller.ts
+import { useEffect as useEffect12, useState as useState12 } from "react";
+var binaryFieldController = (props) => {
+  const {
+    name,
+    methods,
+    readonly = false,
+    filename,
+    onChange: handleOnchange,
+    service,
+    xNode,
+    path,
+    rootField,
+    index,
+    value
+  } = props;
+  const { useUploadFile: useUploadFile2 } = (0, provider_exports.useService)();
+  const { mutateAsync } = useUploadFile2();
+  const [url, setUrl] = useState12(value || null);
+  const [fileInfo, setFileInfo] = useState12(null);
+  useEffect12(() => {
+    if (!value) {
+      setUrl(null);
+      setFileInfo(null);
+      return;
+    }
+    fetchFileMeta(value);
+  }, [value]);
+  const formatSize = (bytes) => {
+    if (bytes < 1024) return bytes + " B";
+    let kb = bytes / 1024;
+    if (kb < 1024) return kb.toFixed(2) + " KB";
+    let mb = kb / 1024;
+    if (mb < 1024) return mb.toFixed(2) + " MB";
+    return (mb / 1024).toFixed(2) + " GB";
+  };
+  const fetchFileMeta = async (url2) => {
+    try {
+      const res = await fetch(url2, { method: "HEAD" });
+      const size = res.headers.get("content-length") || "";
+      let type = res.headers.get("content-type") || "";
+      const date = res.headers.get("last-modified") || "";
+      const guessed = guessTypeFromUrl(url2);
+      if (guessed) type = guessed;
+      setFileInfo({
+        size: size ? formatSize(Number(size)) : "--",
+        type,
+        date: date ? new Date(date).toLocaleString() : "--"
+      });
+      setUrl(url2);
+    } catch (e) {
+      console.error(e);
+    }
+  };
+  const onUploadFile = async (formData) => {
+    const res = await mutateAsync({
+      formData,
+      service,
+      xNode,
+      path
+    });
+    const url2 = res?.url;
+    methods?.setValue(name, url2, { shouldDirty: true });
+    handleOnchange && handleOnchange(name ?? "", url2);
+    if (filename) {
+      methods?.setValue(
+        rootField ? `${rootField?.name}.${index}.${filename}` : filename,
+        url2?.split("/").pop(),
+        { shouldDirty: true }
+      );
+      handleOnchange && handleOnchange(
+        rootField ? `${rootField?.name}.${index}.${filename}` : filename,
+        url2?.split("/").pop()
+      );
+    }
+    setUrl(url2);
+    fetchFileMeta(url2);
+    return url2;
+  };
+  const onDeleteFile = () => {
+    if (filename) {
+      methods?.setValue(
+        rootField ? `${rootField?.name}.${index}.${filename}` : filename,
+        null,
+        { shouldDirty: true }
+      );
+      handleOnchange && handleOnchange(
+        rootField ? `${rootField?.name}.${index}.${filename}` : filename,
+        null
+      );
+    }
+    setUrl(null);
+    setFileInfo(null);
+    methods?.setValue(name, null, { shouldDirty: true });
+    handleOnchange && handleOnchange(name ?? "", null);
+  };
+  return {
+    onUploadFile,
+    onDeleteFile,
+    fileInfo,
+    url
+  };
+};
+
+// src/widget/basic/many2many-binary-field/controller.tsx
+import { useId as useId2, useRef as useRef3, useState as useState13 } from "react";
+var many2manyBinaryController = (props) => {
+  const {
+    name,
+    methods,
+    value,
+    onChange: handleOnchange,
+    service,
+    xNode,
+    path
+  } = props;
+  const inputId = useId2();
+  const { useUploadFile: useUploadFile2 } = (0, provider_exports.useService)();
+  const { mutateAsync } = useUploadFile2();
+  const binaryRef = useRef3(null);
+  const [initialFiles, setInitialFiles] = useState13(
+    Array.isArray(value) ? value : value ? [value] : []
+  );
+  const checkIsImageLink = (url) => {
+    const imageExtensions = /\.(jpg|jpeg|png|gif|bmp|webp|svg|tiff|ico)$/i;
+    return imageExtensions.test(url) || isBase64Image(url) || isBlobUrl(url);
+  };
+  const sanitizeForBE = (list) => list.filter((x) => x?.datas && !isBlobUrl(x.datas)).map((x) => ({ name: x.name, datas: x.datas, mimetype: x.mimetype }));
+  const isBase64Image = (str) => {
+    const base64Regex = /^data:image\/(png|jpeg|jpg|gif|webp);base64,/;
+    if (!base64Regex.test(str)) {
+      return false;
+    }
+    try {
+      const base64Data = str.split(",")[1];
+      return !!base64Data && atob(base64Data).length > 0;
+    } catch (error) {
+      return false;
+    }
+  };
+  const handleFileChange = async (files, e, oldValues) => {
+    try {
+      const uploadedUrls = await Promise.all(
+        files.map(async (f) => {
+          const formData = new FormData();
+          formData.append("file", f);
+          const res = await mutateAsync({ formData, service, xNode, path });
+          return res?.url;
+        })
+      );
+      const uploadedItems = files.map((f, i) => ({
+        name: f.name,
+        datas: uploadedUrls[i] ?? "",
+        mimetype: f.type
+      }));
+      const finalList = [...oldValues, ...uploadedItems];
+      methods?.setValue(name, finalList, { shouldDirty: true });
+      const payloadForBE = sanitizeForBE(finalList);
+      handleOnchange && handleOnchange(name ?? "", payloadForBE);
+    } catch (err) {
+      console.error(err);
+    } finally {
+      e.target.value = "";
+    }
+  };
+  const handleRemoveAt = (idx) => {
+    const current = methods?.getValues(name) || [];
+    const next = current.filter((_, i) => i !== idx);
+    setInitialFiles((p) => p.filter((_, i) => i !== idx));
+    methods?.setValue(name, next.length ? next : null, { shouldDirty: true });
+    const payloadForBE = next.length ? sanitizeForBE(next) : null;
+    handleOnchange && handleOnchange(name ?? "", payloadForBE);
+  };
+  const handleRemoveAll = () => {
+    setInitialFiles([]);
+    methods?.setValue(name, null, { shouldDirty: true });
+    handleOnchange && handleOnchange(name ?? "", null);
+  };
+  return {
+    inputId,
+    initialFiles,
+    binaryRef,
+    handleFileChange,
+    handleRemoveAt,
+    handleRemoveAll,
+    checkIsImageLink,
+    setInitialFiles
+  };
+};
+
+// src/widget/basic/provider-einvoice-field/controller.ts
+var providerEinvoiceFieldController = (props) => {
+  const { relation, formValues, options: fieldOptions, xNode } = props;
+  const { env } = (0, provider_exports.useEnv)();
+  const { action } = useAppProvider();
+  const { useGetSelection: useGetSelection2 } = (0, provider_exports.useService)();
+  const contextObject = {
+    ...(typeof action?.context === "string" ? (0, utils_exports.evalJSONContext)(action?.context) : action?.context) || {},
+    ...env?.context
+  };
+  const optionsObject = typeof fieldOptions === "string" ? (0, utils_exports.evalJSONContext)(fieldOptions, {
+    ...formValues,
+    ...contextObject,
+    context: contextObject,
+    parent: { ...formValues }
+  }) : fieldOptions;
+  const data = {
+    model: optionsObject?.model,
+    domain: optionsObject?.domain,
+    context: {
+      ...contextObject,
+      ...optionsObject?.context
+    },
+    specification: optionsObject?.specification
+  };
+  const { data: listDataCard } = useGetSelection2({
+    data,
+    queryKey: [`data_${relation}`],
+    enabled: true,
+    service: optionsObject?.service,
+    xNode
+  });
+  return {
+    listDataCard
+  };
+};
+
+// src/widget/advance/table/table-head/controller.ts
+import { useMemo as useMemo10, useRef as useRef4 } from "react";
+var tableHeadController = (props) => {
+  const {
+    typeTable,
+    rows,
+    tableRef,
+    groupByList,
+    selectedRowKeys,
+    setSelectedRowKeys
+  } = props;
+  const { rowIds: recordIds } = useGetRowIds(tableRef);
+  const selectedRowKeysRef = useRef4(recordIds);
+  const isGroupTable = typeTable === "group";
+  const recordsCheckedGroup = useMemo10(() => {
+    if (!rows || !groupByList) return 0;
+    const groupBy = typeof groupByList === "object" ? groupByList?.contexts?.[0]?.group_by : void 0;
+    return countSum(rows, groupBy);
+  }, [rows, groupByList]);
+  const isAllGroupChecked = useMemo10(() => {
+    if (!isGroupTable || !selectedRowKeys?.length) return false;
+    const selectedLength = selectedRowKeys.filter((id) => id !== -1).length;
+    const allRecordsSelected = recordIds.length === selectedRowKeys.length ? recordIds.length === selectedLength : false;
+    const allGroupsSelected = recordsCheckedGroup === selectedRowKeys.length;
+    return allGroupsSelected || allRecordsSelected;
+  }, [isGroupTable, selectedRowKeys, recordIds, recordsCheckedGroup]);
+  const isAllNormalChecked = useMemo10(() => {
+    if (isGroupTable || !selectedRowKeys?.length || !rows?.length) return false;
+    return selectedRowKeys.length === rows.length && selectedRowKeys.every(
+      (id) => rows.some((record) => record.id === id)
+    );
+  }, [isGroupTable, selectedRowKeys, rows]);
+  const checkedAll = isAllGroupChecked || isAllNormalChecked;
+  const handleCheckBoxAll = (event) => {
+    if (event?.target?.checked && typeTable === "list") {
+      const allRowKeys = Array.isArray(rows) ? rows.map((record) => record?.id) : [];
+      setSelectedRowKeys(allRowKeys);
+    } else if (event?.target?.checked && typeTable === "group") {
+      const rowsIDs = document.querySelectorAll("tr[data-row-id]");
+      const ids = Array.from(rowsIDs)?.map(
+        (row) => Number(row?.getAttribute("data-row-id"))
+      );
+      if (ids?.length > 0) {
+        setSelectedRowKeys(ids);
+      } else {
+        const sum = countSum(
+          rows,
+          typeof groupByList === "object" ? groupByList?.contexts?.[0]?.group_by : void 0
+        );
+        const keys = Array.from({ length: sum }, (_) => void 0);
+        setSelectedRowKeys(keys);
+      }
+      if (selectedRowKeysRef) {
+        selectedRowKeysRef.current = [];
+      }
+    } else {
+      setSelectedRowKeys([]);
+    }
+  };
+  return {
+    handleCheckBoxAll,
+    checkedAll,
+    selectedRowKeysRef
+  };
+};
+
+// src/widget/advance/table/table-view/controller.ts
+import { useCallback as useCallback6, useEffect as useEffect13, useMemo as useMemo11, useState as useState14 } from "react";
+var tableController = ({ data }) => {
+  const [rows, setRows] = useState14([]);
+  const [columnVisibility, setColumnVisibility] = useState14({});
+  const dataModelFields = useMemo11(() => {
+    return data?.fields?.map((field) => ({
+      ...data.dataModel?.[field?.name],
+      ...field,
+      string: field?.string || data.dataModel?.[field?.name]?.string
+    })) ?? [];
+  }, [data?.fields, data?.dataModel]);
+  const mergeFields = useMemo11(
+    () => mergeButtons(dataModelFields),
+    [dataModelFields]
+  );
+  const transformData = useCallback6(
+    (dataList) => {
+      if (!dataList) return [];
+      return dataList.map((item) => {
+        const transformedItem = { ...item };
+        Object.keys(item).forEach((field) => {
+          if (field !== "__domain") {
+            if (item[field] && typeof item[field] === "object" && item[field].display_name) {
+              transformedItem[field] = item[field];
+            } else if (Array.isArray(item[field]) && item[field].length > 0) {
+              if (data.typeTable === "group" && item[field]?.length === 2 && typeof item[field]?.[1] === "string") {
+                transformedItem["string"] = item[field]?.[1];
+              }
+              transformedItem[field] = item[field];
+            }
+          }
+        });
+        return item.display_name ? { ...transformedItem, item: item.display_name } : transformedItem;
+      });
+    },
+    [data?.typeTable]
+  );
+  useEffect13(() => {
+    setRows(transformData(data?.records));
+  }, [data?.records, transformData]);
+  const columns = useMemo11(() => {
+    try {
+      return mergeFields?.filter((item) => {
+        return item?.widget !== "details_Receive_money" && !(item?.column_invisible ? utils_exports.domainHelper.matchDomains(
+          data.context,
+          item?.column_invisible
+        ) : item?.invisible ? utils_exports.domainHelper.matchDomains(data.context, item?.invisible) : false);
+      })?.map((field) => {
+        const overridden = columnVisibility[field?.name];
+        return {
+          name: field?.name,
+          optional: overridden ?? field?.optional,
+          title: field?.type_co === "button" ? "" : field?.string,
+          field: { ...field }
+        };
+      }) ?? [];
+    } catch (error) {
+      console.error("Error in useTable:", error);
+      return [];
+    }
+  }, [mergeFields, data?.context, columnVisibility]);
+  const onToggleColumnOptional = useCallback6((item) => {
+    setColumnVisibility((prev) => ({
+      ...prev,
+      [item?.name]: item?.optional === "show" ? "hide" : "show"
+    }));
+  }, []);
+  return {
+    rows,
+    columns,
+    onToggleColumnOptional,
+    typeTable: data?.typeTable
+  };
+};
+
+// src/widget/advance/table/table-group/controller.ts
+import { useMemo as useMemo12, useState as useState15 } from "react";
+var tableGroupController = (props) => {
+  const { env } = (0, provider_exports.useEnv)();
+  const { useGetListData: useGetListData2 } = (0, provider_exports.useService)();
+  const {
+    columns,
+    row,
+    model,
+    viewData,
+    level,
+    specification,
+    context,
+    checkedAll,
+    groupByList,
+    setSelectedRowKeys
+  } = props;
+  const [pageGroup, setPageGroup] = useState15(0);
+  const [isShowGroup, setIsShowGroup] = useState15(false);
+  const [colEmptyGroup, setColEmptyGroup] = useState15({
+    fromStart: 1,
+    fromEnd: 1
+  });
+  const domain = row?.__domain;
+  const processedData = useMemo12(() => {
+    const calculateColSpanEmpty = () => {
+      const startIndex = columns.findIndex(
+        (col) => col.field.type === "monetary" && typeof row[col.key] === "number" || col.field.aggregator === "sum"
+      );
+      const endIndex = columns.findLastIndex(
+        (col) => col.field.type === "monetary" && typeof row[col.key] === "number" || col.field.aggregator !== "sum"
+      );
+      const fromStart = startIndex === -1 ? columns.length : startIndex;
+      const fromEnd = endIndex === -1 ? columns.length : columns.length - 1 - endIndex;
+      setColEmptyGroup({ fromStart: fromStart + 1, fromEnd: fromEnd + 1 });
+      return { fromStart: fromStart + 1, fromEnd: fromEnd + 1 };
+    };
+    return calculateColSpanEmpty();
+  }, [columns, row]);
+  const shouldFetchData = useMemo12(() => {
+    return !!isShowGroup;
+  }, [isShowGroup]);
+  const enabled = shouldFetchData && !!processedData;
+  const listDataProps = {
+    model,
+    specification,
+    domain,
+    context,
+    offset: pageGroup * 10,
+    fields: groupByList?.fields,
+    groupby: [groupByList?.contexts[level]?.group_by],
+    limit: 10
+  };
+  const queryKey = [
+    `data-${model}-level_${level}-row-${row?.id}`,
+    specification,
+    domain,
+    pageGroup
+  ];
+  const {
+    data: dataGroup,
+    isFetched: isDataGroupFetched,
+    isLoading,
+    isFetching,
+    isPlaceholderData: isDataPlaceHolder
+  } = useGetListData2(listDataProps, queryKey, enabled);
+  const {
+    columns: columnsGroup,
+    rows: rowsGroup,
+    typeTable: typeTableGroup
+  } = tableController({
+    data: {
+      fields: viewData?.views?.list?.fields,
+      records: dataGroup?.records ?? dataGroup?.groups,
+      dataModel: viewData?.models?.[model],
+      context: env.context,
+      typeTable: dataGroup?.groups ? "group" : "list"
+    }
+  });
+  const group_by_field_name = groupByList?.contexts[level - 1]?.group_by;
+  const nameGroup = Array.isArray(row[group_by_field_name]) ? row?.string ?? row[`${group_by_field_name}`][1] : viewData?.models?.[model]?.[group_by_field_name]?.selection ? viewData.models[model][group_by_field_name].selection.find(
+    (selectItem) => selectItem?.[0] === row[group_by_field_name]
+  )?.[1] : row[group_by_field_name];
+  const toggleShowGroup = () => setIsShowGroup((prev) => !prev);
+  return {
+    // onExpandChildGroup,
+    colEmptyGroup,
+    isShowGroup,
+    isDataGroupFetched,
+    isDataPlaceHolder,
+    // nameGroupWithCount,
+    columnsGroup,
+    rowsGroup,
+    dataGroup,
+    pageGroup,
+    setPageGroup,
+    typeTableGroup
+  };
+};
+
+// src/widget/advance/search/controller.ts
+import { useState as useState16, useEffect as useEffect14, useCallback as useCallback7 } from "react";
+var searchController = ({
+  viewData,
+  model,
+  domain,
+  context,
+  fieldsList,
+  validateAndParseDate,
+  moment
+}) => {
+  const { env } = (0, provider_exports.useEnv)();
+  const [filterBy, setFilterBy] = useState16([]);
+  const [searchBy, setSearchBy] = useState16(null);
+  const [groupBy, setGroupBy] = useState16(null);
+  const [selectedTags, setSelectedTags] = useState16(null);
+  const [searchString, setSearchString] = useState16("");
+  const [searchMap, setSearchMap] = useState16({});
+  const [hoveredIndex, setHoveredIndex] = useState16(0);
+  const [hoveredIndexSearchList, setHoveredIndexSearchList] = useState16(0);
+  const actionContext = typeof context === "string" ? (0, utils_exports.evalJSONContext)(context) : context;
+  const contextSearch = { ...env.context, ...actionContext };
+  const domainAction = domain ? Array.isArray(domain) ? [...domain] : (0, utils_exports.evalJSONDomain)(domain, contextSearch) : [];
+  const resetAllStateSearch = () => {
+    setFilterBy([]);
+    setGroupBy([]);
+    setSearchBy([]);
+    setSelectedTags(null);
+    setSearchString("");
+    setSearchMap({});
+  };
+  const fetchData = async () => {
+    if (viewData) {
+      try {
+        const dataModel = viewData?.models?.[model];
+        const searchViews = viewData?.views?.search;
+        const searchByItems = searchViews?.search_by?.filter(
+          (item) => !utils_exports.domainHelper.matchDomains(contextSearch, item.invisible)
+        )?.map(
+          ({
+            string,
+            name,
+            filter_domain,
+            operator,
+            widget,
+            class: classSearchItem,
+            placeholder
+          }, index) => ({
+            placeholder,
+            class: classSearchItem,
+            dataIndex: index,
+            title: string ?? dataModel?.[name]?.string,
+            name: name ?? dataModel?.[name]?.name,
+            filter_domain,
+            operator,
+            widget,
+            type: dataModel?.[name]?.type
+          })
+        );
+        const filterByItems = searchViews?.filter_by.filter((item) => {
+          return !utils_exports.domainHelper.matchDomains(contextSearch, item?.invisible);
+        })?.map((item) => ({ ...item, active: false }));
+        const groupByItems = searchViews?.group_by.filter(
+          (item) => !utils_exports.domainHelper.matchDomains(contextSearch, item?.invisible)
+        ).map((item) => ({
+          ...item,
+          string: item.string ?? viewData?.models?.[model]?.[item?.name?.split("group_by_")?.[1]]?.string
+        }));
+        setSearchBy(searchByItems);
+        setFilterBy(filterByItems);
+        setGroupBy(groupByItems);
+      } catch (error) {
+        console.error("Error fetching data:", error);
+      }
+    }
+  };
+  useEffect14(() => {
+    fetchData();
+  }, [model, viewData]);
+  const onChangeSearchInput = (search_string) => {
+    setSearchString(search_string);
+  };
+  const removeKeyFromSearchMap = ({
+    key,
+    item
+  }) => {
+    const values = searchMap[key];
+    if (!values) return searchMap;
+    const newSearchMap = { ...searchMap };
+    if (item) {
+      const filtered = values.filter((value) => value.name !== item.name);
+      if (filtered.length > 0) {
+        newSearchMap[key] = filtered;
+      } else {
+        delete newSearchMap[key];
+      }
+    } else {
+      delete newSearchMap[key];
+    }
+    setSearchMap(newSearchMap);
+  };
+  const updateSearchMap = ({ key, item }) => {
+    const newSearchMap = { ...searchMap };
+    const currentValues = searchMap[key] ?? [];
+    newSearchMap[key] = [...currentValues, item];
+    setSearchMap(newSearchMap);
+  };
+  const removeSearchItems = (key, item) => {
+    removeKeyFromSearchMap({ key: String(key), item });
+  };
+  const addSearchItems = (key, newItem) => {
+    updateSearchMap({ key, item: newItem });
+  };
+  const formatDomain = () => {
+    if (domainAction) {
+      const domain2 = [];
+      if (Array.isArray(domainAction) && domainAction.length > 0) {
+        if (Object.keys(searchMap).some((key) => !key.includes(constants_exports.SearchType.GROUP))) {
+          domain2.push("&");
+        }
+        domainAction.forEach((domainItem) => {
+          domain2.push(domainItem);
+        });
+      }
+      Object.keys(searchMap).forEach((key, keyIndex, keys) => {
+        if (!key?.includes(constants_exports.SearchType.GROUP)) {
+          if (keys.length > 1 && keyIndex < keys.length - 1) {
+            domain2.push("&");
+          }
+          const valuesOfKey = searchMap[key];
+          valuesOfKey.forEach((value, index) => {
+            if (index < valuesOfKey.length - 1) {
+              domain2.push("|");
+            }
+            if (value.domain) {
+              domain2.push(...value.domain);
+              return;
+            }
+            let valueDomainItem = value?.value;
+            if (value?.modelType === "date") {
+              valueDomainItem = validateAndParseDate(value?.value);
+            } else if (value?.modelType === "datetime") {
+              if (value?.operator === "<=" || value?.operator === "<") {
+                const parsedDate = validateAndParseDate(value?.value, true);
+                const hasTime = moment(value?.value).format("HH:mm:ss") !== "00:00:00";
+                valueDomainItem = hasTime ? moment(parsedDate).format("YYYY-MM-DD HH:mm:ss") : moment(parsedDate).add(1, "day").subtract(1, "second").format("YYYY-MM-DD HH:mm:ss");
+              } else {
+                valueDomainItem = validateAndParseDate(value?.value, true);
+              }
+            }
+            const operator = value?.modelType === "date" || value?.modelType === "datetime" || value?.modelType === "boolean" || value?.modelType === "integer" ? value?.operator ?? "=" : value.operator ?? "ilike";
+            domain2.push([value.name, operator, valueDomainItem]);
+          });
+        }
+      });
+      return [...domain2];
+    }
+  };
+  const setTagSearch = useCallback7(
+    (updatedMap) => {
+      if (!updatedMap) return;
+      const tagsSearch = Object.entries(updatedMap).map(
+        ([key, objValues]) => {
+          const {
+            title,
+            name,
+            groupIndex,
+            type,
+            widget,
+            modelType,
+            dataIndex,
+            date
+          } = objValues[0];
+          if (!key?.includes(constants_exports.SearchType.GROUP)) {
+            const values = objValues?.map((objValue) => objValue.value);
+            return {
+              title,
+              name: type === constants_exports.SearchType.SEARCH ? `${constants_exports.SearchType.SEARCH}_${String(dataIndex)}` : groupIndex ?? name,
+              values,
+              type,
+              widget,
+              modelType,
+              date
+            };
+          } else {
+            const contexts = [];
+            let groupValues = [];
+            objValues?.forEach((objValue) => {
+              const { context: context2, value, active, groupIndex: groupIndex2, isDefault } = objValue;
+              const indexAppend = groupIndex2 != null ? groupIndex2 : viewData?.views?.search?.filters_by?.length ?? 0;
+              contexts.push(
+                ...Array.isArray(context2?.group_by) ? context2.group_by.map((item) => ({ group_by: item })) : [context2]
+              );
+              groupValues[indexAppend] = {
+                contexts: [
+                  ...Array.isArray(context2?.group_by) ? context2.group_by.map((item) => ({
+                    group_by: item
+                  })) : [context2]
+                ],
+                strings: isDefault ? [value] : [...groupValues[indexAppend]?.strings ?? [], value]
+              };
+            });
+            const fields = [
+              ...new Set(fieldsList?.map((item) => item?.name))
+            ];
+            const groupByTag = {
+              title,
+              values: groupValues?.filter(
+                (item) => item !== void 0
+              ),
+              type,
+              contexts,
+              fields
+            };
+            return groupByTag;
+          }
+        }
+      );
+      setSelectedTags(tagsSearch);
+      setSearchString("");
+    },
+    [searchMap]
+  );
+  const removeSearchItemsByType = (type) => {
+    const newSearchMap = {};
+    Object.entries(searchMap).forEach(([key, values]) => {
+      const isGroup = key.includes(constants_exports.SearchType.GROUP);
+      const isFilter = key.includes(constants_exports.SearchType.FILTER);
+      const isSearch = key.includes(constants_exports.SearchType.SEARCH);
+      if (type === constants_exports.SearchType.GROUP && isGroup) return;
+      if (type === constants_exports.SearchType.FILTER && isFilter) return;
+      if (type === constants_exports.SearchType.SEARCH && isSearch) return;
+      newSearchMap[key] = values;
+    });
+    setSearchMap(newSearchMap);
+  };
+  useEffect14(() => {
+    setTagSearch(searchMap);
+  }, [searchMap]);
+  const handleAddTagSearch = (tag) => {
+    const { domain: domain2, groupIndex, value, type, context: context2, dataIndex } = tag;
+    const domainFormat = new utils_exports.domainHelper.Domain(domain2);
+    if (type === constants_exports.SearchType.FILTER) {
+      addSearchItems(`${constants_exports.SearchType.FILTER}_${groupIndex}`, {
+        ...tag,
+        domain: domain2 ? domainFormat.toList(context2) : null
+      });
+    } else if (type === constants_exports.SearchType.SEARCH) {
+      addSearchItems(`${constants_exports.SearchType.SEARCH}_${String(dataIndex)}`, {
+        ...tag,
+        domain: domain2 ? domainFormat.toList({
+          ...context2,
+          self: value
+        }) : null
+      });
+    } else if (type === constants_exports.SearchType.GROUP) {
+      addSearchItems(`${constants_exports.SearchType.GROUP}`, {
+        ...tag,
+        domain: domain2 ? domainFormat.toList({
+          context: context2,
+          self: value
+        }) : null
+      });
+    }
+  };
+  const onKeyDown = (e) => {
+    if (!searchBy || searchBy.length === 0) return;
+    switch (e.key) {
+      case "Backspace": {
+        if (!searchString && selectedTags && selectedTags.length > 0) {
+          const lastTag = selectedTags[selectedTags.length - 1];
+          if (!lastTag) return;
+          const key = lastTag.type === constants_exports.SearchType.GROUP ? constants_exports.SearchType.GROUP : lastTag.name;
+          removeKeyFromSearchMap({ key: String(key) });
+        }
+        break;
+      }
+      case "ArrowDown": {
+        e.preventDefault();
+        setHoveredIndex((prev) => {
+          const maxIndex = searchBy.length - 1;
+          const next = prev < maxIndex ? prev + 1 : prev;
+          setHoveredIndexSearchList(next);
+          return next;
+        });
+        break;
+      }
+      case "ArrowUp": {
+        e.preventDefault();
+        setHoveredIndex((prev) => {
+          const next = prev > 0 ? prev - 1 : prev;
+          setHoveredIndexSearchList(next);
+          return next;
+        });
+        break;
+      }
+      case "Enter": {
+        e.preventDefault();
+        if (!searchString.trim()) return;
+        const head = searchBy[hoveredIndex];
+        if (!head) return;
+        handleAddTagSearch({
+          title: head.title,
+          name: head.name,
+          value: searchString,
+          type: constants_exports.SearchType.SEARCH,
+          domain: head.filter_domain,
+          operator: head.operator,
+          dataIndex: head.dataIndex,
+          widget: head.widget,
+          modelType: head.type
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  };
+  const handleMouseEnter = (index) => {
+    setHoveredIndexSearchList(index);
+  };
+  const handleMouseLeave = () => {
+    setHoveredIndexSearchList(null);
+  };
+  return {
+    groupBy,
+    searchBy,
+    filterBy,
+    selectedTags,
+    searchString,
+    setFilterBy,
+    setGroupBy,
+    setSearchBy,
+    resetAllStateSearch,
+    setSelectedTags,
+    removeSearchItems,
+    onSearchString: onChangeSearchInput,
+    handleAddTagSearch,
+    domain: formatDomain(),
+    context: contextSearch,
+    onKeyDown,
+    handleMouseEnter,
+    handleMouseLeave,
+    hoveredIndexSearchList,
+    removeSearchItemsByType
+  };
+};
+export {
+  binaryFieldController,
+  colorFieldController,
+  copyLinkButtonController,
+  downLoadBinaryController,
+  downloadFileController,
+  durationController,
+  many2manyBinaryController,
+  many2manyFieldController,
+  many2manyTagsController,
+  many2oneButtonController,
+  many2oneFieldController,
+  priorityFieldController,
+  providerEinvoiceFieldController,
+  searchController,
+  statusDropdownController,
+  tableController,
+  tableGroupController,
+  tableHeadController
+};