@m4l/core 0.1.23 → 0.1.24

package/contexts/DomainContext/index.js

@@ -0,0 +1,51 @@
+import { createContext, useState, useEffect } from "react";
+import { u as useFlags } from "../../hooks/useFlags/index.js";
+import { u as useEnvironment } from "../../hooks/useEnvironment/index.js";
+import { u as useNetwork } from "../../hooks/useNetwork/index.js";
+import { C as CommonFlags } from "../../types/index.js";
+import { jsx } from "react/jsx-runtime";
+const DomainContext = createContext(null);
+function DomainProvider(props) {
+  const {
+    children
+  } = props;
+  const {
+    domain_token
+  } = useEnvironment();
+  const {
+    addFlag
+  } = useFlags();
+  const [domain, setDomain] = useState({
+    company_logo_small_url: "",
+    company_logo_normal_url: "",
+    name: ""
+  });
+  const {
+    networkOperation
+  } = useNetwork();
+  useEffect(() => {
+    let mounted = true;
+    networkOperation({
+      method: "GET",
+      endPoint: `na/info/${domain_token}`
+    }).then((response) => {
+      if (mounted) {
+        setDomain({
+          ...response.data
+        });
+        addFlag(CommonFlags.FLAG_DOMAIN_LOADED);
+      }
+    }).finally(() => {
+    });
+    return function cleanUp() {
+      mounted = false;
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(DomainContext.Provider, {
+    value: {
+      ...domain
+    },
+    children
+  });
+}
+export { DomainContext as D, DomainProvider as a };

package/contexts/DomainCountryContext/index.js

@@ -0,0 +1,52 @@
+import { createContext, useState, useCallback, useEffect } from "react";
+import "../EnvironmentContext/index.js";
+import "../FlagsContext/index.js";
+import { u as useHostTools } from "../../hooks/useHostTools/index.js";
+import "../DomainContext/index.js";
+import "../ModuleDictionaryContext/index.js";
+import "../ModulePrivilegesContext/index.js";
+import "../ModuleSkeletonContext/index.js";
+import "../NetworkContext/index.js";
+import { E as EmitEvents } from "../../types/index.js";
+import { jsx } from "react/jsx-runtime";
+const DomainCountryContext = createContext(null);
+function DomainCountryProvider(props) {
+  const {
+    children,
+    isMicroFrontEnd,
+    domainCountryId
+  } = props;
+  const {
+    events_add_listener,
+    events_remove_listener,
+    events_emit
+  } = useHostTools();
+  const [finaDomainCountryId, setFinalDomainCountry] = useState(domainCountryId);
+  const onUpdateDomainCountry = useCallback((newDomainCountryId) => {
+    setFinalDomainCountry(newDomainCountryId);
+  }, []);
+  useEffect(() => {
+    if (isMicroFrontEnd) {
+      events_add_listener(EmitEvents.EMMIT_EVENT_HOST_DOMAIN_COUNTRY_CHANGE, onUpdateDomainCountry);
+    }
+    return () => {
+      if (isMicroFrontEnd) {
+        events_remove_listener(EmitEvents.EMMIT_EVENT_HOST_DOMAIN_COUNTRY_CHANGE, onUpdateDomainCountry);
+      }
+    };
+  }, []);
+  const changeDomainCountryId = useCallback((newDomainCountryId) => {
+    if (!isMicroFrontEnd) {
+      setFinalDomainCountry(newDomainCountryId);
+      events_emit(EmitEvents.EMMIT_EVENT_HOST_DOMAIN_COUNTRY_CHANGE, newDomainCountryId);
+    }
+  }, []);
+  return /* @__PURE__ */ jsx(DomainCountryContext.Provider, {
+    value: {
+      domainCountryId: finaDomainCountryId,
+      changeDomainCountryId
+    },
+    children
+  });
+}
+export { DomainCountryContext as D, DomainCountryProvider as a };

package/contexts/EnvironmentContext/index.js

@@ -0,0 +1,15 @@
+import { createContext, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+const EnvironmentContext = createContext(null);
+function EnvironmentProvider(props) {
+  const {
+    children,
+    ...other
+  } = props;
+  const [finalEnvironment] = useState(other);
+  return /* @__PURE__ */ jsx(EnvironmentContext.Provider, {
+    value: finalEnvironment,
+    children
+  });
+}
+export { EnvironmentContext as E, EnvironmentProvider as a };

package/contexts/FlagsContext/index.js

@@ -0,0 +1,28 @@
+import { createContext, useState, useCallback } from "react";
+import { jsx } from "react/jsx-runtime";
+const FlagsContext = createContext(null);
+function FlagsProvider({
+  children
+}) {
+  const [flags, setFlags] = useState([]);
+  const clearFlags = useCallback(() => {
+    setFlags([]);
+  }, []);
+  const addFlag = useCallback((newFlag) => {
+    setFlags((oldFlags) => {
+      if (oldFlags.findIndex((f) => f === newFlag) < 0) {
+        return [...oldFlags, newFlag];
+      }
+      return [...oldFlags];
+    });
+  }, []);
+  return /* @__PURE__ */ jsx(FlagsContext.Provider, {
+    value: {
+      flags,
+      addFlag,
+      clearFlags
+    },
+    children
+  });
+}
+export { FlagsContext as F, FlagsProvider as a };

package/contexts/HostToolsContext/index.js

@@ -0,0 +1,15 @@
+import { createContext, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+const HostToolsContext = createContext(null);
+function HostToolsProvider(props) {
+  const {
+    children,
+    ...hostTools
+  } = props;
+  const [finalTools] = useState(hostTools);
+  return /* @__PURE__ */ jsx(HostToolsContext.Provider, {
+    value: finalTools,
+    children
+  });
+}
+export { HostToolsContext as H, HostToolsProvider as a };

package/contexts/ModuleDictionaryContext/index.js

@@ -0,0 +1,94 @@
+import { createContext, useState, useEffect, useCallback } from "react";
+import { u as useEnvironment } from "../../hooks/useEnvironment/index.js";
+import { u as useFlags } from "../../hooks/useFlags/index.js";
+import { u as useHostTools } from "../../hooks/useHostTools/index.js";
+import "../DomainContext/index.js";
+import "../ModulePrivilegesContext/index.js";
+import "../ModuleSkeletonContext/index.js";
+import { u as useNetwork } from "../../hooks/useNetwork/index.js";
+import "../DomainCountryContext/index.js";
+import { C as CommonFlags } from "../../types/index.js";
+import { jsx } from "react/jsx-runtime";
+const ModuleDictionaryContext = createContext(null);
+function ModuleDictionaryProvider(props) {
+  const {
+    children,
+    componentsDictionary,
+    moduleId,
+    moduleName = "module_name",
+    currentLang = "en",
+    isAuth = true
+  } = props;
+  const {
+    addFlag
+  } = useFlags();
+  const [moduleDictionary, setModuleDictionary] = useState(void 0);
+  const {
+    domain_token
+  } = useEnvironment();
+  const {
+    startProgress,
+    stopProgress
+  } = useHostTools();
+  const {
+    networkOperation
+  } = useNetwork();
+  useEffect(() => {
+    let mounted = true;
+    startProgress();
+    networkOperation({
+      method: "GET",
+      endPoint: isAuth ? `dictionaries/${moduleId}` : `na/dictionaries/${moduleId}`,
+      parms: {
+        comps: componentsDictionary,
+        ...isAuth ? {} : {
+          domain_token,
+          lang: currentLang
+        }
+      }
+    }).then((response) => {
+      if (mounted) {
+        setModuleDictionary({
+          ...response
+        });
+        addFlag(CommonFlags.FLAG_DICTIONARY_LOADED);
+      }
+    }).finally(() => {
+      stopProgress();
+    });
+    return function cleanUp() {
+      mounted = false;
+    };
+  }, [currentLang]);
+  const getLabel = useCallback((key) => {
+    if (moduleDictionary === void 0)
+      return "";
+    if (key === "")
+      return "No key";
+    let ret = void 0;
+    const parts = key.split(".");
+    try {
+      if (parts.length === 1) {
+        ret = moduleDictionary.data[key];
+      }
+      if (parts.length === 2) {
+        ret = moduleDictionary[parts[0]][parts[1]];
+      }
+    } catch (error) {
+    }
+    if (ret) {
+      return ret;
+    }
+    return `N_D:[${key}]`;
+  }, [moduleDictionary]);
+  const getModuleLabel = useCallback(() => getLabel(moduleName), [moduleName, getLabel]);
+  return /* @__PURE__ */ jsx(ModuleDictionaryContext.Provider, {
+    value: {
+      moduleDictionary,
+      getLabel,
+      getModuleLabel
+    },
+    children
+  });
+}
+export { ModuleDictionaryContext as M, ModuleDictionaryProvider as a };

package/contexts/ModulePrivilegesContext/index.js

@@ -0,0 +1,67 @@
+import { createContext, useState, useEffect, useCallback } from "react";
+import "../EnvironmentContext/index.js";
+import { u as useFlags } from "../../hooks/useFlags/index.js";
+import { u as useHostTools } from "../../hooks/useHostTools/index.js";
+import "../DomainContext/index.js";
+import "../ModuleDictionaryContext/index.js";
+import "../ModuleSkeletonContext/index.js";
+import { u as useNetwork } from "../../hooks/useNetwork/index.js";
+import "../DomainCountryContext/index.js";
+import { C as CommonFlags } from "../../types/index.js";
+import { jsx } from "react/jsx-runtime";
+const ModulePrivilegesContext = createContext(null);
+function ModulePrivilegesProvider(props) {
+  const {
+    children,
+    queryPrivileges
+  } = props;
+  const {
+    addFlag
+  } = useFlags();
+  const [privileges, setPrivileges] = useState({});
+  const {
+    startProgress,
+    stopProgress
+  } = useHostTools();
+  const {
+    networkOperation
+  } = useNetwork();
+  useEffect(() => {
+    let mounted = true;
+    if (queryPrivileges.length === 0) {
+      addFlag(CommonFlags.FLAG_PRIVILEGES_LOADED);
+      return;
+    }
+    startProgress();
+    networkOperation({
+      method: "GET",
+      endPoint: `auth/login`,
+      parms: {
+        privileges: queryPrivileges
+      }
+    }).then((response) => {
+      if (mounted) {
+        setPrivileges({
+          ...response.data
+        });
+        addFlag(CommonFlags.FLAG_PRIVILEGES_LOADED);
+      }
+    }).finally(() => {
+      stopProgress();
+    });
+    return function cleanUp() {
+      mounted = false;
+    };
+  }, []);
+  const hasPrivilege = useCallback((key) => {
+    return key in privileges;
+  }, [privileges]);
+  return /* @__PURE__ */ jsx(ModulePrivilegesContext.Provider, {
+    value: {
+      hasPrivilege,
+      privileges
+    },
+    children
+  });
+}
+export { ModulePrivilegesContext as M, ModulePrivilegesProvider as a };

package/contexts/ModuleSkeletonContext/index.js

@@ -0,0 +1,25 @@
+import { createContext } from "react";
+import "../EnvironmentContext/index.js";
+import { a as useFlagsPresent } from "../../hooks/useFlags/index.js";
+import "../HostToolsContext/index.js";
+import "../DomainContext/index.js";
+import "../ModuleDictionaryContext/index.js";
+import "../ModulePrivilegesContext/index.js";
+import "../NetworkContext/index.js";
+import "../DomainCountryContext/index.js";
+import { jsx } from "react/jsx-runtime";
+const ModuleSkeletonContext = createContext(null);
+function ModuleSkeletonProvider(props) {
+  const {
+    children,
+    flags
+  } = props;
+  const isSkeleton = !useFlagsPresent(flags);
+  return /* @__PURE__ */ jsx(ModuleSkeletonContext.Provider, {
+    value: {
+      isSkeleton
+    },
+    children
+  });
+}
+export { ModuleSkeletonContext as M, ModuleSkeletonProvider as a };

package/contexts/NetworkContext/index.js

@@ -0,0 +1,23 @@
+import { createContext, useCallback } from "react";
+import { u as useEnvironment } from "../../hooks/useEnvironment/index.js";
+import { u as useHostTools } from "../../hooks/useHostTools/index.js";
+import { jsx } from "react/jsx-runtime";
+const NetworkContext = createContext(null);
+function NetworkProvider(props) {
+  const {
+    children,
+    axiosOperation
+  } = props;
+  const environment = useEnvironment();
+  const hostTools = useHostTools();
+  const networkOperation = useCallback(async (networkProps) => {
+    return axiosOperation(networkProps, environment, hostTools);
+  }, [axiosOperation]);
+  return /* @__PURE__ */ jsx(NetworkContext.Provider, {
+    value: {
+      networkOperation
+    },
+    children
+  });
+}
+export { NetworkContext as N, NetworkProvider as a };

package/hooks/useDomain/index.js

@@ -0,0 +1,16 @@
+import { useContext } from "react";
+import { D as DomainContext } from "../../contexts/DomainContext/index.js";
+import { D as DomainCountryContext } from "../../contexts/DomainCountryContext/index.js";
+const useDomain = () => {
+  const context = useContext(DomainContext);
+  if (!context)
+    throw new Error("useDomain context must be use inside DomainContext");
+  return context;
+};
+const useDomainCountry = () => {
+  const context = useContext(DomainCountryContext);
+  if (!context)
+    throw new Error("useDomainCountry context must be use inside DomainCountryContext");
+  return context;
+};
+export { useDomainCountry as a, useDomain as u };

package/hooks/useEnvironment/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { E as EnvironmentContext } from "../../contexts/EnvironmentContext/index.js";
+const useEnvironment = () => {
+  const context = useContext(EnvironmentContext);
+  if (!context)
+    throw new Error("useEnvironment context must be use inside EnvironmentContext");
+  return context;
+};
+export { useEnvironment as u };

package/hooks/useFlags/index.js

@@ -0,0 +1,23 @@
+import { useContext, useState, useEffect } from "react";
+import { F as FlagsContext } from "../../contexts/FlagsContext/index.js";
+const useFlags = () => {
+  const context = useContext(FlagsContext);
+  if (!context)
+    throw new Error("useFlags context must be use inside FlagsProvider");
+  return context;
+};
+function isFlagsPresent(compareFlags, flags) {
+  const filterFlags = compareFlags.filter((findFlag) => flags.findIndex((sFlag) => sFlag === findFlag) !== -1);
+  return filterFlags.length === compareFlags.length;
+}
+const useFlagsPresent = (compareFlags) => {
+  const context = useFlags();
+  const [isPresent, setIsPresent] = useState(isFlagsPresent(compareFlags, context.flags));
+  useEffect(() => {
+    if (isFlagsPresent(compareFlags, context.flags)) {
+      setIsPresent(true);
+    }
+  }, [context.flags, compareFlags]);
+  return isPresent;
+};
+export { useFlagsPresent as a, useFlags as u };

package/hooks/useHostTools/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { H as HostToolsContext } from "../../contexts/HostToolsContext/index.js";
+const useHostTools = () => {
+  const context = useContext(HostToolsContext);
+  if (!context)
+    throw new Error("useHostTools context must be use inside HostToolsContext");
+  return context;
+};
+export { useHostTools as u };

package/hooks/useLocalStorage/index.js

@@ -0,0 +1,54 @@
+import { useState, useEffect } from "react";
+function useLocalStorage(key, initialValue) {
+  const [value, setValue] = useState(() => {
+    try {
+      const item = window.localStorage.getItem(key);
+      return item !== null ? JSON.parse(item) : initialValue;
+    } catch (e) {
+      return initialValue;
+    }
+  });
+  const setValueInLocalStorage = (newValue) => {
+    try {
+      window.localStorage.setItem(key, JSON.stringify(newValue));
+      setValue(newValue);
+    } catch (e) {
+    }
+  };
+  return [value, setValueInLocalStorage];
+}
+function useLocalStorageWithListener(key, defaultValue) {
+  const [value, setValue] = useState(() => {
+    try {
+      const storedValue = localStorage.getItem(key);
+      return storedValue === null ? defaultValue : JSON.parse(storedValue);
+    } catch (e) {
+      return defaultValue;
+    }
+  });
+  useEffect(() => {
+    const listener = (e) => {
+      if (e.storageArea === localStorage && e.key === key) {
+        try {
+          if (e.newValue) {
+            setValue(JSON.parse(e.newValue));
+          }
+        } catch (_e) {
+        }
+      }
+    };
+    window.addEventListener("storage", listener);
+    return () => {
+      window.removeEventListener("storage", listener);
+    };
+  }, [key, defaultValue]);
+  const setValueInLocalStorage = (newValue) => {
+    setValue((currentValue) => {
+      const result = typeof newValue === "function" ? newValue(currentValue) : newValue;
+      localStorage.setItem(key, JSON.stringify(result));
+      return result;
+    });
+  };
+  return [value, setValueInLocalStorage];
+}
+export { useLocalStorageWithListener as a, useLocalStorage as u };

package/hooks/useModuleDictionary/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { M as ModuleDictionaryContext } from "../../contexts/ModuleDictionaryContext/index.js";
+const useModuleDictionary = () => {
+  const context = useContext(ModuleDictionaryContext);
+  if (!context)
+    throw new Error("useModuleDictionary context must be use inside ModuleDictionaryProvider");
+  return context;
+};
+export { useModuleDictionary as u };

package/hooks/useModulePrivileges/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { M as ModulePrivilegesContext } from "../../contexts/ModulePrivilegesContext/index.js";
+const useModulePrivileges = () => {
+  const context = useContext(ModulePrivilegesContext);
+  if (!context)
+    throw new Error("useModulePrivileges context must be use inside ModulePrivilegesContext");
+  return context;
+};
+export { useModulePrivileges as u };

package/hooks/useModuleSkeleton/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { M as ModuleSkeletonContext } from "../../contexts/ModuleSkeletonContext/index.js";
+const useModuleSkeleton = () => {
+  const context = useContext(ModuleSkeletonContext);
+  if (!context)
+    throw new Error("useModuleSkeleton context must be use inside ModuleSkeletonContext");
+  return context.isSkeleton;
+};
+export { useModuleSkeleton as u };

package/hooks/useNetwork/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { N as NetworkContext } from "../../contexts/NetworkContext/index.js";
+const useNetwork = () => {
+  const context = useContext(NetworkContext);
+  if (!context)
+    throw new Error("useNetwork context must be use inside NetworkContext");
+  return context;
+};
+export { useNetwork as u };

package/hooks/usePaginate/index.js

@@ -0,0 +1,85 @@
+import { useState, useRef, useCallback, useEffect } from "react";
+import { u as useHostTools } from "../useHostTools/index.js";
+import { u as useNetwork } from "../useNetwork/index.js";
+const initialPagerState = {
+  page: 0,
+  rowsPerPage: 25,
+  totalRecords: 0
+};
+const usePaginate = (props) => {
+  const {
+    endPoint,
+    timeout = 5e3,
+    queryParams,
+    fireOnChangeParms,
+    rowsPerPage = initialPagerState.rowsPerPage
+  } = props;
+  const [refresh, setRefresh] = useState(fireOnChangeParms ? 1 : 0);
+  const [rows, setRows] = useState([]);
+  const [pagerState, setPagerState] = useState({ ...initialPagerState, rowsPerPage });
+  const refPagerState = useRef({ ...initialPagerState, rowsPerPage });
+  const [firstQueryParams, setFirstQueryParams] = useState(true);
+  const { startProgress, stopProgress } = useHostTools();
+  const { networkOperation } = useNetwork();
+  const Refresh = useCallback(() => {
+    setRefresh((oldValue) => oldValue + 1);
+  }, []);
+  useEffect(() => {
+    if (firstQueryParams) {
+      setFirstQueryParams(false);
+      return;
+    }
+    if (fireOnChangeParms) {
+      Refresh();
+    }
+  }, [queryParams]);
+  useEffect(() => {
+    let mounted = true;
+    if (refresh === 0)
+      return;
+    startProgress();
+    networkOperation({
+      method: "GET",
+      endPoint,
+      timeout,
+      parms: {
+        ...queryParams,
+        page: refPagerState.current.page,
+        limit: refPagerState.current.rowsPerPage
+      }
+    }).then((response) => {
+      if (mounted) {
+        setRows(response.data);
+        refPagerState.current.page = response.pager.page;
+        setPagerState((oldPagerState) => ({
+          ...oldPagerState,
+          page: response.pager.page,
+          totalRecords: response.pager.total
+        }));
+      }
+    }).finally(() => {
+      if (mounted) {
+        stopProgress();
+      }
+    });
+    return function cleanUp() {
+      stopProgress();
+      mounted = false;
+    };
+  }, [refresh]);
+  const onPageChange = (newPage) => {
+    refPagerState.current.page = newPage;
+    setRefresh((oldValue) => oldValue + 1);
+  };
+  const onRowsPerPageChange = (newRowsPerPage) => {
+    refPagerState.current.rowsPerPage = newRowsPerPage;
+    setPagerState((oldPagerState) => ({ ...oldPagerState, rowsPerPage: newRowsPerPage }));
+    setRefresh((oldValue) => oldValue + 1);
+  };
+  const clearRows = () => {
+    setRows([]);
+    setPagerState(initialPagerState);
+  };
+  return { onPageChange, onRowsPerPageChange, pagerState, rows, clearRows, Refresh };
+};
+export { initialPagerState as i, usePaginate as u };

package/index.js

@@ -1,4 +1,26 @@
-export * from "./contexts";
-export * from "./hooks";
-export { CommonFlags, EmitEvents } from "./types";
-export * from "./utils";
+import "react";
+export { E as EnvironmentContext, a as EnvironmentProvider } from "./contexts/EnvironmentContext/index.js";
+export { F as FlagsContext, a as FlagsProvider } from "./contexts/FlagsContext/index.js";
+export { H as HostToolsContext, a as HostToolsProvider } from "./contexts/HostToolsContext/index.js";
+export { D as DomainContext, a as DomainProvider } from "./contexts/DomainContext/index.js";
+export { M as ModuleDictionaryContext, a as ModuleDictionaryProvider } from "./contexts/ModuleDictionaryContext/index.js";
+export { M as ModulePrivilegesContext, a as ModulePrivilegesProvider } from "./contexts/ModulePrivilegesContext/index.js";
+export { M as ModuleSkeletonContext, a as ModuleSkeletonProvider } from "./contexts/ModuleSkeletonContext/index.js";
+export { N as NetworkContext, a as NetworkProvider } from "./contexts/NetworkContext/index.js";
+export { D as DomainCountryContext, a as DomainCountryProvider } from "./contexts/DomainCountryContext/index.js";
+export { u as useEnvironment } from "./hooks/useEnvironment/index.js";
+export { u as useFlags, a as useFlagsPresent } from "./hooks/useFlags/index.js";
+export { u as useHostTools } from "./hooks/useHostTools/index.js";
+export { u as useDomain, a as useDomainCountry } from "./hooks/useDomain/index.js";
+export { u as useLocalStorage, a as useLocalStorageWithListener } from "./hooks/useLocalStorage/index.js";
+export { u as useModuleDictionary } from "./hooks/useModuleDictionary/index.js";
+export { u as useModulePrivileges } from "./hooks/useModulePrivileges/index.js";
+export { u as useModuleSkeleton } from "./hooks/useModuleSkeleton/index.js";
+export { u as useNetwork } from "./hooks/useNetwork/index.js";
+export { i as initialPagerState, u as usePaginate } from "./hooks/usePaginate/index.js";
+export { C as CommonFlags, E as EmitEvents } from "./types/index.js";
+export { a as getLocalStorage, g as getPropertyByString, s as setLocalStorage, v as voidFunction } from "./utils/index.js";
+export { a as axiosOperation } from "./utils/axiosOperation.js";
+import "react/jsx-runtime";
+import "axios";
+import "qs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m4l/core",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "license": "UNLICENSED",
   "author": "M4L Team",
   "peerDependencies": {

package/types/index.js

@@ -0,0 +1,13 @@
+var EmitEvents = /* @__PURE__ */ ((EmitEvents2) => {
+  EmitEvents2["EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED"] = `netsevice_unauthorized`;
+  EmitEvents2["EMMIT_EVENT_HOST_THEME_CHANGE"] = "host_theme_change";
+  EmitEvents2["EMMIT_EVENT_HOST_DOMAIN_COUNTRY_CHANGE"] = "domain_country_change";
+  return EmitEvents2;
+})(EmitEvents || {});
+var CommonFlags = /* @__PURE__ */ ((CommonFlags2) => {
+  CommonFlags2["FLAG_PRIVILEGES_LOADED"] = "privileges_loaded";
+  CommonFlags2["FLAG_DICTIONARY_LOADED"] = "dictionary_loaded";
+  CommonFlags2["FLAG_DOMAIN_LOADED"] = "domain_loaded";
+  return CommonFlags2;
+})(CommonFlags || {});
+export { CommonFlags as C, EmitEvents as E };

package/utils/axiosOperation.js

@@ -0,0 +1,95 @@
+import axios from "axios";
+import qs from "qs";
+import { E as EmitEvents } from "../types/index.js";
+function getResponse(endPoint, response, hostTools) {
+  const { toast } = hostTools;
+  if (response && response.data && typeof response.data === "object") {
+    if (response.data.error && response.data.error?.code && response.data.error?.msg !== void 0) {
+      return Promise.reject({ ...response.data.error, status: response.status });
+    }
+    if (response.data.message) {
+      toast(response.data.message, { type: "success", autoClose: 1e4 });
+    }
+    return response.data;
+  }
+  return Promise.reject({
+    code: 1,
+    msg: `Incorrect endpoint: ${endPoint}`,
+    status: response.status
+  });
+}
+function getError(error, hostTools, checkUnAuthorized = true) {
+  const { toast } = hostTools;
+  console.log("Ingres\xF3");
+  let err = {
+    message: "",
+    status: 1,
+    code: 0
+  };
+  if (error?.code !== void 0 && err.status !== void 0 && error.message !== void 0) {
+    err = { ...err, ...error };
+  }
+  if (error?.response) {
+    if (error.response.data && typeof error.response.data === "object" && error.response.data.error && error.response.data.error?.code && error.response.data.error?.message !== void 0) {
+      err = { ...error.response.data.error, status: error.response.status };
+    } else {
+      err.message = error.message;
+      err.status = error.response.status;
+      err.code = 0;
+    }
+  } else if (error?.request) {
+    err.message = `${error?.code} ${error.message}`;
+    err.code = -1;
+  } else {
+    err.message = `${error?.code} ${error.message}`;
+    err.status = 0;
+    err.code = -2;
+  }
+  if (checkUnAuthorized && error?.response?.status === 401) {
+    hostTools.events_emit(EmitEvents.EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED, {});
+  }
+  if (error?.response?.data?.error?.message) {
+    err.message = error?.response?.data?.error.message;
+  }
+  if (checkUnAuthorized) {
+    toast(`${err.message} - status: ${err.status} - code: ${err.code}`, { type: "error" });
+  }
+  return err;
+}
+const axiosOperation = async (props, enviroment, hostTools) => {
+  const {
+    method,
+    endPoint,
+    timeout = 5e3,
+    parms = {},
+    data = {},
+    isRemote = true,
+    checkUnAuthorized = true,
+    headers
+  } = props;
+  let baseURL;
+  if (isRemote) {
+    baseURL = enviroment.host_api_remote;
+  } else {
+    baseURL = enviroment.host_api_local;
+  }
+  hostTools.startProgress();
+  return axios({
+    baseURL,
+    withCredentials: isRemote,
+    method,
+    url: `/${endPoint}`,
+    data,
+    params: {},
+    paramsSerializer: () => {
+      return qs.stringify(parms, { encode: true });
+    },
+    headers,
+    timeout
+  }).then((response) => {
+    return getResponse(endPoint, response, hostTools);
+  }).catch((error) => Promise.reject(getError(error, hostTools, checkUnAuthorized))).finally(() => {
+    hostTools.stopProgress();
+  });
+};
+export { axiosOperation as a };

package/utils/index.js

@@ -0,0 +1,35 @@
+import "axios";
+import "qs";
+function voidFunction() {
+}
+function getPropertyByString(object, key) {
+  let value = object;
+  const props = key.split(".");
+  for (let index = 0; index < props.length; index += 1) {
+    if (value[props[index]] === void 0)
+      break;
+    value = value[props[index]];
+  }
+  return value;
+}
+function getLocalStorage(key, initialValue) {
+  try {
+    const item = window.localStorage.getItem(key);
+    return item !== null ? JSON.parse(item) : initialValue;
+  } catch (e) {
+    return initialValue;
+  }
+}
+function setLocalStorage(key, newValue, mixCurrentLocalStorage = false) {
+  try {
+    let item = null;
+    if (mixCurrentLocalStorage) {
+      item = window.localStorage.getItem(key);
+    }
+    let value = item !== null ? JSON.parse(item) : {};
+    value = { ...value, ...newValue };
+    window.localStorage.setItem(key, JSON.stringify(value));
+  } catch (_e) {
+  }
+}
+export { getLocalStorage as a, getPropertyByString as g, setLocalStorage as s, voidFunction as v };