@fctc/widget-logic 1.10.0 → 1.10.1

package/dist/hooks.mjs

@@ -0,0 +1,883 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/hooks/core/use-call-action.ts
+import { useState } from "react";
+import { getEnv } from "@fctc/interface-logic/environment";
+import { useLoadAction, useRunAction } from "@fctc/interface-logic/hooks";
+var useCallAction = () => {
+  const queryLoadAction = useLoadAction();
+  const queryRunAction = useRunAction();
+  const [data, setData] = useState(void 0);
+  const callAction = async ({
+    aid,
+    actionType = "ir.actions.act_window"
+  }) => {
+    const context = getEnv().context;
+    let res = void 0;
+    if (actionType === "ir.actions.act_window") {
+      res = await queryLoadAction.mutateAsync({
+        idAction: aid,
+        context
+      });
+    } else if (actionType === "ir.actions.server") {
+      res = await queryRunAction.mutateAsync({
+        idAction: aid,
+        context
+      });
+    }
+    setData(res);
+    return res;
+  };
+  return [data, callAction];
+};
+
+// src/hooks/core/use-config.ts
+import { useEffect, useMemo } from "react";
+import { getEnv as getEnv2 } from "@fctc/interface-logic/environment";
+import { useAppDispatch, setEnvFile } from "@fctc/interface-logic/store";
+var useConfig = ({ localStorageUtils, sessionStorageUtils }) => {
+  const dispatch = useAppDispatch();
+  const envConfig = useMemo(() => {
+    return {
+      mode: "development",
+      baseUrl: "https://api.vitrust.app/c2/api/v2",
+      config: {
+        grantType: "password",
+        clientId: "C52foVQSMpnNOcAP2CBIIkupOSfxUarF8nlOPfXM",
+        clientSecret: "rColINr4a9QBFQPqQB8YU1XfBjqzwerDMJGBxsFK"
+      }
+    };
+  }, []);
+  const config = useMemo(() => {
+    return {
+      VITE_SIDEBAR_TYPE: "grid/sidebar",
+      VITE_APP_DOMAIN: "https://api.vitrust.app/c2/",
+      VITE_IS_EDU: true,
+      VITE_LOGO_WHITE_LOGIN: "https://static.vitrust.app/vitrust/3a/3a1301f614dea6ee19ebf99b68f57e3fd46011d2.png",
+      VITE_LOGO_BLACK_LOGIN: "https://static.vitrust.app/vitrust/32/3223918780da7a439f916faac9abf0bfe98dfa07.png",
+      VITE_BACKGROUND_SIDEBAR: "linear-gradient(178deg, rgb(1, 106, 13) -0.89%, rgb(4, 179, 66) 99.46%",
+      VITE_BANNER: "https://static.vitrust.app/vitrust/5d/5d20cab0627182b4ed5cba4ee42c58b98b663e5b.svg",
+      VITE_BG_BUTTON: "#008F3C",
+      VITE_BACKGROUND_PAGE: "#F9FAFB"
+    };
+  }, []);
+  useEffect(() => {
+    try {
+      const env = getEnv2();
+      env.setupEnv({
+        baseUrl: envConfig.baseUrl,
+        port: 3e3,
+        config: {
+          grantType: envConfig.config.grantType,
+          clientId: envConfig.config.clientId,
+          clientSecret: envConfig.config.clientSecret
+        },
+        db: "preschool",
+        localStorageUtils: localStorageUtils(),
+        sessionStorageUtils: sessionStorageUtils()
+      });
+      dispatch(setEnvFile(config));
+    } catch (error) {
+      console.error("Error loading env or config:", error);
+    }
+  }, [dispatch, envConfig, config]);
+  return { envConfig, config };
+};
+
+// src/hooks/core/use-detail.ts
+import { setProfile, useAppDispatch as useAppDispatch2 } from "@fctc/interface-logic/store";
+import { useQuery } from "@tanstack/react-query";
+import { useEffect as useEffect2 } from "react";
+import { useGetDetail } from "@fctc/interface-logic/hooks";
+var useDetail = (accessToken, sub) => {
+  const dispatch = useAppDispatch2();
+  const fetchGetDetail = useGetDetail();
+  const userDetailQuery = useQuery({
+    queryKey: ["userDetailQuery", sub && accessToken],
+    queryFn: () => {
+      return fetchGetDetail.mutateAsync({
+        model: "res.users",
+        ids: [sub],
+        specification: { image_256: {} }
+      });
+    },
+    enabled: !!sub && !!accessToken
+  });
+  useEffect2(() => {
+    if (userDetailQuery.data) {
+      const userPicture = userDetailQuery.data;
+      dispatch(
+        setProfile({ ...userPicture, image: userPicture?.[0]?.image_256 })
+      );
+    }
+  }, [userDetailQuery.data, dispatch]);
+  return userDetailQuery;
+};
+
+// src/hooks/core/use-list-data.ts
+import { useMemo as useMemo3, useState as useState3 } from "react";
+
+// src/utils/function.ts
+import {
+  useCallback,
+  useEffect as useEffect3,
+  useMemo as useMemo2,
+  useReducer,
+  useRef,
+  useState as useState2
+} from "react";
+
+// src/store.ts
+var store_exports = {};
+__reExport(store_exports, store_star);
+import * as store_star from "@fctc/interface-logic/store";
+
+// src/utils/function.ts
+var countSum = (data, field) => {
+  if (!data || !field) return 0;
+  return data.reduce(
+    (total, item) => total + (item?.[`${field}_count`] || 0),
+    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;
+}
+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;
+  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;
+}
+function useGetRowIds(tableRef) {
+  const [rowIds, setRowIds] = useState2([]);
+  const lastRowIdsRef = useRef([]);
+  const updateVisibleRowIds = 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]);
+  useEffect3(() => {
+    const table = tableRef?.current;
+    if (!table) return;
+    const observer = new MutationObserver(() => {
+      updateVisibleRowIds();
+    });
+    observer.observe(table, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["style", "class"]
+    });
+    updateVisibleRowIds();
+    return () => {
+      observer.disconnect();
+    };
+  }, [updateVisibleRowIds, tableRef]);
+  return { rowIds, refresh: updateVisibleRowIds };
+}
+var useSelectionState = ({
+  typeTable,
+  tableRef,
+  rows
+}) => {
+  const { groupByDomain } = (0, store_exports.useAppSelector)(store_exports.selectSearch);
+  const { selectedRowKeys } = (0, store_exports.useAppSelector)(store_exports.selectList);
+  const { rowIds: recordIds } = useGetRowIds(tableRef);
+  const selectedRowKeysRef = useRef(recordIds);
+  const isGroupTable = typeTable === "group";
+  const recordsCheckedGroup = useMemo2(() => {
+    if (!rows || !groupByDomain) return 0;
+    const groupBy = typeof groupByDomain === "object" ? groupByDomain?.contexts?.[0]?.group_by : void 0;
+    return countSum(rows, groupBy);
+  }, [rows, groupByDomain]);
+  const isAllGroupChecked = useMemo2(() => {
+    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 = useMemo2(() => {
+    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;
+  return { checkedAll, selectedRowKeysRef };
+};
+var getDateRange = (currentDate, unit) => {
+  const date = new Date(currentDate);
+  let dateStart, dateEnd;
+  function formatDate(d) {
+    return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0") + " " + String(d.getHours()).padStart(2, "0") + ":" + String(d.getMinutes()).padStart(2, "0") + ":" + String(d.getSeconds()).padStart(2, "0");
+  }
+  switch (unit) {
+    case "month":
+      dateStart = new Date(
+        date.getFullYear(),
+        date.getMonth() + 1,
+        date.getDate(),
+        23,
+        59,
+        59
+      );
+      dateStart.setHours(dateStart.getHours() - 7);
+      dateEnd = new Date(date.getFullYear(), date.getMonth(), 0, 0, 0, 0);
+      dateEnd.setHours(dateEnd.getHours() - 7);
+      break;
+    case "day":
+      dateStart = new Date(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate(),
+        23,
+        59,
+        59
+      );
+      dateStart.setHours(dateStart.getHours() - 7);
+      dateEnd = new Date(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate(),
+        0,
+        0,
+        0
+      );
+      dateEnd.setHours(dateEnd.getHours() - 7);
+      break;
+    case "week":
+      const dayOfWeek = date.getDay();
+      const daysToMonday = dayOfWeek === 0 ? -6 : 1 - dayOfWeek;
+      const daysToSunday = dayOfWeek === 0 ? 0 : 7 - dayOfWeek;
+      dateStart = new Date(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate() + daysToSunday,
+        23,
+        59,
+        59
+      );
+      dateStart.setHours(dateStart.getHours() - 7);
+      dateEnd = new Date(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate() + daysToMonday,
+        0,
+        0,
+        0
+      );
+      dateEnd.setHours(dateEnd.getHours() - 7);
+      break;
+    case "year":
+      dateStart = new Date(date.getFullYear(), 11, 31, 23, 59, 59);
+      dateStart.setHours(dateStart.getHours() - 7);
+      dateEnd = new Date(date.getFullYear() - 1, 11, 31, 0, 0, 0);
+      dateEnd.setHours(dateEnd.getHours() - 7);
+      break;
+    default:
+      throw new Error(
+        "\u0110\u01A1n v\u1ECB kh\xF4ng h\u1EE3p l\u1EC7. Ch\u1EC9 ch\u1EA5p nh\u1EADn: week, day, month, year"
+      );
+  }
+  return [
+    ["date_start", "<=", formatDate(dateStart)],
+    ["date_end", ">=", formatDate(dateEnd)]
+  ];
+};
+var convertFieldsToArray = (fields) => {
+  const defaultFields = ["display_name", "date_start", "date_end"];
+  if (!fields || !Array.isArray(fields)) {
+    return defaultFields;
+  }
+  const inputFields = fields.filter((field) => field && field.type_co === "field").map((field) => field.name);
+  return [...defaultFields, ...inputFields];
+};
+function combineContexts(contexts) {
+  if (contexts.some((context) => !context)) {
+    return void 0;
+  } else {
+    const res = contexts.reduce((acc, context) => {
+      return { ...acc, ...context };
+    }, {});
+    return res;
+  }
+}
+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();
+  useEffect3(() => {
+    try {
+      const storedValue = localStorage.getItem(key);
+      setState(storedValue);
+    } catch (e) {
+      console.error("Local storage is unavailable:", e);
+    }
+  }, [key]);
+  const setValue = useCallback(
+    (value) => {
+      setState(value);
+      setStorageItemAsync(key, value);
+    },
+    [key]
+  );
+  return [state, setValue];
+}
+
+// src/hooks/core/use-list-data.ts
+import { useModel, useGetListData } from "@fctc/interface-logic/hooks";
+import {
+  useAppSelector as useAppSelector2,
+  selectSearch as selectSearch2,
+  selectList as selectList2
+} from "@fctc/interface-logic/store";
+import {
+  evalJSONDomain,
+  formatSortingString
+} from "@fctc/interface-logic/utils";
+var useListData = ({
+  action,
+  context,
+  viewResponse
+}) => {
+  const { groupByDomain } = useAppSelector2(selectSearch2);
+  const initModel = useModel();
+  const [type, setType] = useState3("list");
+  const [mode, setMode] = useState3("month");
+  const [currentDate, setCurrentDate] = useState3(/* @__PURE__ */ new Date());
+  const { pageLimit, page, order } = useAppSelector2(selectList2);
+  const listDataProps = useMemo3(() => {
+    const actData = action?.result;
+    if (!viewResponse || !actData || !context) {
+      return null;
+    }
+    const specification = initModel.initModel({
+      name: String(actData.res_model),
+      view: viewResponse || {},
+      actContext: context,
+      fields: type === "kanban" ? viewResponse?.views?.kanban?.fields : type === "calendar" ? viewResponse?.views?.calendar?.fields : viewResponse?.views?.list?.fields
+    }).getSpecification();
+    const domain = type === "calendar" ? getDateRange(currentDate, mode) : actData?.domain ? Array.isArray(actData?.domain) ? [...actData?.domain] : evalJSONDomain(actData?.domain, context) : [];
+    const limit = type === "calendar" ? 2500 : pageLimit;
+    const offset = page * pageLimit;
+    const fields = type === "calendar" ? convertFieldsToArray(viewResponse?.views?.calendar?.fields) || [] : typeof groupByDomain === "object" ? groupByDomain?.fields : void 0;
+    const groupby = typeof groupByDomain === "object" ? [groupByDomain?.contexts?.[0]?.group_by] : [];
+    const sort = order ? order : viewResponse?.views?.list?.default_order ? formatSortingString(viewResponse?.views?.list?.default_order) : "";
+    return {
+      model: actData.res_model,
+      specification,
+      domain,
+      limit,
+      offset,
+      fields,
+      groupby,
+      context,
+      sort,
+      type
+    };
+  }, [
+    action?.result,
+    context,
+    currentDate,
+    groupByDomain,
+    initModel,
+    mode,
+    order,
+    page,
+    pageLimit,
+    type,
+    viewResponse
+  ]);
+  const list = useGetListData(
+    listDataProps,
+    [listDataProps],
+    !!listDataProps
+  );
+  return {
+    ...list,
+    state: {
+      type,
+      setType,
+      mode,
+      setMode,
+      currentDate,
+      setCurrentDate
+    }
+  };
+};
+
+// src/hooks/core/use-menu.ts
+import { useEffect as useEffect4, useMemo as useMemo4, useState as useState4 } from "react";
+
+// src/utils/constants.ts
+var languages = [
+  { id: "vi_VN", name: "VIE" },
+  { id: "en_US", name: "ENG" }
+];
+var API_PRESCHOOL_URL = {
+  baseURL: "https://preschool.vitrust.app"
+};
+var API_APP_URL = {
+  baseUrl: "https://api.vitrust.app",
+  c2: "https://api.vitrust.app/c2",
+  apiV2: "https://api.vitrust.app/c2/api/v2"
+};
+
+// src/hooks/core/use-menu.ts
+import { useGetMenu } from "@fctc/interface-logic/hooks";
+var useMenu = ({ context }) => {
+  const menuData = useGetMenu(context, !!context);
+  const [menuid, setMenuId] = useState4(void 0);
+  const [action, setAction] = useCallAction();
+  const configedIconData = useMemo4(() => {
+    const data = menuData.data;
+    return data?.map((item) => {
+      return {
+        ...item,
+        child_id: item?.child_id?.map((child) => {
+          return {
+            ...child,
+            url_icon: API_APP_URL.c2 + "/" + child.url_icon
+          };
+        }) ?? [],
+        url_icon: API_APP_URL.c2 + "/" + item.url_icon
+      };
+    });
+  }, [menuData.data]);
+  const handleChangeMenu = async ({
+    menu,
+    subMenu
+  }) => {
+    const aid = subMenu?.action?.id?.id;
+    const actionType = subMenu?.action?.type;
+    await setAction({
+      aid: Number(aid),
+      actionType
+    });
+    if (menu) {
+      setMenuId(menu.id?.toString() ?? "");
+    }
+  };
+  useEffect4(() => {
+    const firstRecord = configedIconData?.[0];
+    const firstChild = firstRecord?.child_id?.[0];
+    if (firstChild && firstRecord) {
+      handleChangeMenu({ menu: firstRecord, subMenu: firstChild });
+    }
+  }, [configedIconData]);
+  return {
+    ...menuData,
+    data: configedIconData,
+    action: { handleChangeMenu },
+    state: { menuid, action },
+    context
+  };
+};
+
+// src/hooks/core/use-profile.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { useEffect as useEffect5, useMemo as useMemo5 } from "react";
+import { useTranslation } from "react-i18next";
+import { getEnv as getEnv3 } from "@fctc/interface-logic/environment";
+import { useGetProfile } from "@fctc/interface-logic/hooks";
+import { useAppDispatch as useAppDispatch3, setDataUser } from "@fctc/interface-logic/store";
+var useProfile = (accessToken) => {
+  const getProfile = useGetProfile();
+  const dispatch = useAppDispatch3();
+  const { i18n } = useTranslation();
+  const fetchUserProfile = async () => {
+    return await getProfile.mutateAsync();
+  };
+  const userInfoQuery = useQuery2({
+    queryKey: ["userInfo", accessToken],
+    queryFn: fetchUserProfile,
+    enabled: !!accessToken
+  });
+  useEffect5(() => {
+    if (userInfoQuery.data) {
+      const userInfo = userInfoQuery.data;
+      const env = getEnv3();
+      env.setUid(userInfo?.sub);
+      dispatch(setDataUser(userInfo));
+      const userLocale = languages.find((lang) => lang?.id === userInfo?.locale);
+      env.setLang(userLocale?.id);
+      i18n.changeLanguage(userLocale?.id.split("_")[0]);
+    }
+  }, [dispatch, userInfoQuery.data]);
+  const context = useMemo5(() => {
+    if (userInfoQuery.data?.sub && userInfoQuery.data?.locale) {
+      return {
+        uid: Number(userInfoQuery.data.sub),
+        allowed_company_ids: [],
+        lang: String(userInfoQuery.data.locale),
+        tz: "Asia/Saigon"
+      };
+    }
+    return void 0;
+  }, [userInfoQuery.data]);
+  return { ...userInfoQuery, context };
+};
+
+// src/hooks/core/use-user.ts
+var useUser = (accessToken) => {
+  const userProfile = useProfile(accessToken);
+  const userDetail = useDetail(accessToken, userProfile.data?.sub);
+  return { userProfile, userDetail, context: userProfile.context };
+};
+
+// src/hooks/core/use-view-v2.ts
+import { useMemo as useMemo6 } from "react";
+import { useGetView } from "@fctc/interface-logic/hooks";
+var useViewV2 = ({
+  action,
+  context
+}) => {
+  const viewParams = useMemo6(() => {
+    if (!action?.result) {
+      return void 0;
+    }
+    const actionResult = action?.result;
+    return {
+      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
+    };
+  }, [action, context]);
+  const view = useGetView(
+    viewParams || {},
+    !!viewParams
+  );
+  return {
+    ...view,
+    context
+  };
+};
+
+// src/hooks/core/use-auth.ts
+import { useLoginCredential } from "@fctc/interface-logic/hooks";
+import {
+  setDataUser as setDataUser2,
+  setMenuList,
+  setProfile as setProfile2,
+  useAppDispatch as useAppDispatch4
+} from "@fctc/interface-logic/store";
+var useAuth = () => {
+  const [[isLoading, accessToken], setAccessToken] = useStorageState("TOKEN");
+  const loginMutate = useLoginCredential();
+  const dispatch = useAppDispatch4();
+  const signIn = async (email, password) => {
+    try {
+      loginMutate.mutate(
+        {
+          email,
+          password,
+          path: "/authentication/oauth2/token"
+        },
+        {
+          onSuccess: (res) => {
+          },
+          onError: (err) => {
+          }
+        }
+      );
+    } catch (error) {
+      throw new Error("Login failed");
+    }
+  };
+  const signOut = async () => {
+    dispatch(setMenuList([]));
+    dispatch(setDataUser2({}));
+    dispatch(setProfile2({}));
+    setAccessToken(null);
+  };
+  return {
+    signIn,
+    signOut,
+    accessToken,
+    isLoading
+  };
+};
+
+// src/hooks/core/use-app-provider.tsx
+import { createContext, useContext, useMemo as useMemo8 } from "react";
+
+// src/hooks/core/use-company.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { useEffect as useEffect6, useMemo as useMemo7 } from "react";
+import { getEnv as getEnv4 } from "@fctc/interface-logic/environment";
+import {
+  useGetCurrentCompany,
+  useGetCompanyInfo
+} from "@fctc/interface-logic/hooks";
+var useCompany = (accessToken) => {
+  const getCurrentCompany = useGetCurrentCompany();
+  const fetchCurrentCompany = async () => {
+    return await getCurrentCompany.mutateAsync();
+  };
+  const currentCompany = useQuery3({
+    queryKey: ["currentCompany", accessToken],
+    queryFn: fetchCurrentCompany,
+    enabled: !!accessToken
+  });
+  const current_company_id = useMemo7(() => {
+    return currentCompany.data?.current_company_id;
+  }, [currentCompany.data]);
+  useEffect6(() => {
+    if (current_company_id) {
+      const companyIDs = [current_company_id];
+      const env = getEnv4();
+      env.setAllowCompanies([...companyIDs]);
+      env.setCompanies(companyIDs);
+    }
+  }, [current_company_id]);
+  const getCompanyInfo = useGetCompanyInfo();
+  const companyInfo = useQuery3({
+    queryKey: ["companyInfoQuery", current_company_id, accessToken],
+    queryFn: () => getCompanyInfo.mutateAsync(Number(current_company_id)),
+    enabled: !!current_company_id && !!accessToken
+  });
+  useEffect6(() => {
+    if (companyInfo.data) {
+      const companyInfoData = companyInfo.data;
+      if (companyInfoData?.length) {
+        const env = getEnv4();
+        env.setDefaultCompany(companyInfoData[0]);
+      }
+    }
+  }, [companyInfo.data]);
+  return {
+    currentCompany,
+    companyInfo,
+    context: { allowed_company_ids: [current_company_id] }
+  };
+};
+var use_company_default = useCompany;
+
+// src/hooks/core/use-app-provider.tsx
+import { evalJSONContext } from "@fctc/interface-logic/utils";
+import { jsx } from "react/jsx-runtime";
+var AppProviderInitialValue = {
+  config: {},
+  user: {},
+  auth: {},
+  company: {},
+  action: {},
+  menu: {},
+  view: {},
+  list: {}
+};
+var ReactContext = createContext(AppProviderInitialValue);
+var AppProvider = ({ children }) => {
+  const config = useConfig({});
+  const auth = useAuth();
+  const user = useUser(auth.accessToken);
+  const company = use_company_default(auth.accessToken);
+  const menuContext = useMemo8(() => {
+    return combineContexts([user.context, company.context]);
+  }, [user.context, company.context]);
+  const menu = useMenu({ context: menuContext });
+  const action = useMemo8(() => {
+    return menu.state.action;
+  }, [menu.state.action]);
+  const viewContext = useMemo8(() => {
+    return combineContexts([
+      menuContext,
+      { ...evalJSONContext(action?.result?.context) }
+    ]);
+  }, [menuContext, action?.result?.context]);
+  const view = useViewV2({
+    action,
+    context: viewContext
+  });
+  const list = useListData({
+    action,
+    viewResponse: view.data,
+    context: viewContext
+  });
+  return /* @__PURE__ */ jsx(
+    ReactContext.Provider,
+    {
+      value: {
+        config,
+        auth,
+        user,
+        company,
+        menu,
+        list,
+        action,
+        view
+      },
+      children
+    }
+  );
+};
+var useAppProvider = () => {
+  const context = useContext(ReactContext);
+  if (!context) {
+    return AppProviderInitialValue;
+  }
+  return context;
+};
+
+// src/hooks/core/use-menu-item.tsx
+import { getEnv as getEnv5 } from "@fctc/interface-logic/environment";
+import { useGetActionDetail } from "@fctc/interface-logic/hooks";
+import { useState as useState5 } from "react";
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  API_APP_URL: () => API_APP_URL,
+  API_PRESCHOOL_URL: () => API_PRESCHOOL_URL,
+  STORAGES: () => STORAGES,
+  combineContexts: () => combineContexts,
+  convertFieldsToArray: () => convertFieldsToArray,
+  countSum: () => countSum,
+  getDateRange: () => getDateRange,
+  languages: () => languages,
+  mergeButtons: () => mergeButtons,
+  setStorageItemAsync: () => setStorageItemAsync,
+  useGetRowIds: () => useGetRowIds,
+  useSelectionState: () => useSelectionState,
+  useStorageState: () => useStorageState
+});
+__reExport(utils_exports, utils_star);
+import * as utils_star from "@fctc/interface-logic/utils";
+
+// src/hooks/utils/use-click-outside.ts
+import { useEffect as useEffect7, useRef as useRef2 } from "react";
+var DEFAULT_EVENTS = ["mousedown", "touchstart"];
+var useClickOutside = ({
+  handler,
+  events = DEFAULT_EVENTS,
+  nodes = [],
+  refs
+}) => {
+  const ref = useRef2(null);
+  useEffect7(() => {
+    const listener = (event) => {
+      const { target } = event;
+      if (refs && refs?.length > 0 && refs?.some((r) => r.current?.contains(target))) {
+        return;
+      }
+      if (!(target instanceof HTMLElement)) return;
+      const shouldIgnore = target.hasAttribute("data-ignore-outside-clicks") || !document.body.contains(target) && target.tagName !== "HTML";
+      const shouldTrigger = nodes.length > 0 ? nodes.every((node) => node && !event.composedPath().includes(node)) : ref.current && !ref.current.contains(target);
+      if (shouldTrigger && !shouldIgnore) {
+        handler(event);
+      }
+    };
+    events.forEach((event) => document.addEventListener(event, listener));
+    return () => {
+      events.forEach((event) => document.removeEventListener(event, listener));
+    };
+  }, [handler, nodes, events]);
+  return ref;
+};
+
+// src/hooks/utils/use-debounce.ts
+import { useEffect as useEffect8, useState as useState6 } from "react";
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState6(value);
+  useEffect8(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return [debouncedValue];
+}
+
+// src/hooks.ts
+export * from "@fctc/interface-logic/hooks";
+export {
+  AppProvider,
+  useAppProvider,
+  useAuth,
+  useCallAction,
+  useClickOutside,
+  useConfig,
+  useDebounce,
+  useDetail,
+  useListData,
+  useMenu,
+  useProfile,
+  useUser,
+  useViewV2
+};