@m4l/components 3.1.9 → 4.0.0

package/components/MFIsolationApp/MFIsolationApp-gs8L4yRC.js

@@ -0,0 +1,123 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useMemo, useCallback } from "react";
+import { unstable_HistoryRouter } from "react-router-dom";
+import { createBrowserHistory } from "history";
+import EventEmitter from "eventemitter3";
+import NProgress from "nprogress";
+import { LocalesProvider, getLocaleFromNetwork, ResponsiveContainerProvider } from "@m4l/graphics";
+import { EnvironmentProvider, HostToolsProvider, NetworkProvider, axiosOperation, AuthProvider } from "@m4l/core";
+import { T as TOAST_CONTAINER_ID } from "./constants-pKuV2ytz.js";
+import { c as createToaster } from "../ToastContainer/helpers/toaster-DzYEKmB3.js";
+import { M as MFAuthApp } from "./subcomponents/MFAuthApp/MFAuthApp-_B9NLBK_.js";
+import { T as ToastContainer } from "../ToastContainer/ToastContainer-CbeZ1op9.js";
+import { B as BaseModule } from "../BaseModule/BaseModule-ut5-cA-D.js";
+import { A as AreasProvider } from "../areas/contexts/AreasContext/index-CII5Xc1a.js";
+const history = createBrowserHistory({ window });
+function MFIsolationApp(props) {
+  const {
+    children,
+    user,
+    pwd,
+    database = "domain",
+    // 'domain
+    host_api_local,
+    host_api_remote,
+    host_static_assets,
+    environment_assets,
+    moduleId,
+    skeletonFlags,
+    moduleNameField,
+    privileges,
+    componentsDictionary,
+    onLoad,
+    activeAreasNetwork = false,
+    activeCookiesFromNetwork = false,
+    observedDivRef
+  } = props;
+  const eventEmitter = useMemo(() => new EventEmitter(), []);
+  const events_add_listener = useCallback(
+    (eventName, handler) => {
+      eventEmitter.on(eventName, handler);
+    },
+    [eventEmitter]
+  );
+  const events_remove_listener = useCallback(
+    (eventName, handler) => {
+      if (handler === null) {
+        eventEmitter.removeListener(eventName);
+        return;
+      }
+      eventEmitter.removeListener(eventName, handler);
+    },
+    [eventEmitter]
+  );
+  const events_emit = useCallback(
+    (eventName, arg) => {
+      eventEmitter.emit(eventName, arg);
+    },
+    [eventEmitter]
+  );
+  const startProgress = () => {
+    NProgress.configure({
+      showSpinner: true
+    });
+    NProgress.start();
+  };
+  const stopProgress = () => {
+    NProgress.done();
+  };
+  const environment = useMemo(
+    () => ({
+      host: "",
+      isLocalhost: true,
+      domain_token: "lab1",
+      database,
+      host_api_local,
+      host_api_remote,
+      host_static_assets,
+      environment_assets
+    }),
+    []
+  );
+  const toaster = createToaster(TOAST_CONTAINER_ID);
+  const hostTools = useMemo(
+    () => ({
+      history,
+      toast: toaster,
+      startProgress,
+      stopProgress,
+      events_add_listener,
+      events_remove_listener,
+      events_emit
+    }),
+    []
+  );
+  return /* @__PURE__ */ jsx(EnvironmentProvider, { ...environment, children: /* @__PURE__ */ jsx(HostToolsProvider, { ...hostTools, children: /* @__PURE__ */ jsx(NetworkProvider, { axiosOperation, children: /* @__PURE__ */ jsx(unstable_HistoryRouter, { history, children: /* @__PURE__ */ jsx(LocalesProvider, { isMicroFrontEnd: false, getLocaleFromNetwork, children: /* @__PURE__ */ jsx(AuthProvider, { children: /* @__PURE__ */ jsxs(MFAuthApp, { user, pwd, children: [
+    /* @__PURE__ */ jsx(ToastContainer, { containerId: TOAST_CONTAINER_ID }),
+    /* @__PURE__ */ jsx(
+      BaseModule,
+      {
+        moduleId,
+        privileges,
+        skeletonFlags,
+        componentsDictionary,
+        moduleNameField,
+        children: /* @__PURE__ */ jsx(
+          AreasProvider,
+          {
+            onLoad,
+            loadAreasFromNetwork: activeAreasNetwork,
+            loadCookiesFromNetwork: activeCookiesFromNetwork,
+            onSelectLayout: (modId) => {
+              console.log("onSelectLayout", modId);
+            },
+            children: /* @__PURE__ */ jsx(ResponsiveContainerProvider, { observedDivRef, children })
+          }
+        )
+      }
+    )
+  ] }) }) }) }) }) }) });
+}
+export {
+  MFIsolationApp as M
+};

package/components/MFIsolationApp/constants-pKuV2ytz.js

@@ -0,0 +1,4 @@
+const TOAST_CONTAINER_ID = "toast-host";
+export {
+  TOAST_CONTAINER_ID as T
+};

package/components/MFIsolationApp/index-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/components/MFIsolationApp/subcomponents/MFAuthApp/MFAuthApp-_B9NLBK_.js

@@ -0,0 +1,55 @@
+import { jsx } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { format } from "date-fns";
+import { useAuth, DomainCountryProvider } from "@m4l/core";
+import { HostThemeProvider, FormatterProvider } from "@m4l/graphics";
+import { defaultThemeOptions, fnComponentsOverrides } from "@m4l/styles";
+function MFAuthApp(props) {
+  const { children, user, pwd } = props;
+  const { isAuthenticated, isInitialized, login, user: authUser } = useAuth();
+  useEffect(() => {
+    if (isInitialized && isAuthenticated === false) {
+      login(user, pwd, false);
+    }
+  }, [isInitialized, isAuthenticated]);
+  if (!isAuthenticated) return /* @__PURE__ */ jsx("div", { children: "Pendiente por autenticarse" });
+  const domianCountry = {
+    id: 1,
+    currency: "USD",
+    currency_decimal_digits: 2,
+    decimal_symbol: ".",
+    thousands_symbol: ","
+  };
+  if (authUser?.domain_country) {
+    domianCountry.id = authUser?.domain_country.id ?? domianCountry.id;
+    domianCountry.currency = authUser?.domain_country.currency ?? domianCountry.currency;
+    domianCountry.currency_decimal_digits = authUser?.domain_country.currency_decimal_digits ?? domianCountry.currency_decimal_digits;
+    domianCountry.decimal_symbol = authUser?.domain_country.decimal_symbol ?? domianCountry.decimal_symbol;
+    domianCountry.thousands_symbol = authUser?.domain_country?.thousands_symbol ?? domianCountry.thousands_symbol;
+  }
+  return /* @__PURE__ */ jsx(
+    HostThemeProvider,
+    {
+      hostThemeOptions: defaultThemeOptions,
+      fnComponentsOverrides,
+      isMicroFrontEnd: true,
+      children: /* @__PURE__ */ jsx(DomainCountryProvider, { ...domianCountry, isMicroFrontEnd: false, children: /* @__PURE__ */ jsx(
+        FormatterProvider,
+        {
+          isMicroFrontEnd: false,
+          dateFormatter: {
+            formatDate: format
+          },
+          currencyFormatter: {
+            code: domianCountry.currency,
+            decimalDigits: domianCountry.currency_decimal_digits
+          },
+          children
+        }
+      ) })
+    }
+  );
+}
+export {
+  MFAuthApp as M
+};

package/components/MFIsolationApp/subcomponents/MFAuthApp/index-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/components/MFLoader/MFLoader-D8pXQmRc.js

@@ -0,0 +1,153 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useState, useCallback, useEffect } from "react";
+import { useNetwork, useEnvironment, useHostTools, axiosOperation } from "@m4l/core";
+import { useHostTheme, useFormatter, useLocales, useFirstRender } from "@m4l/graphics";
+import debounce from "lodash/debounce";
+import { P as ProggessLoadingMF } from "./subcomponents/ProggessLoadingMF/index-D8tU4EJM.js";
+import { O as ObservableLoaderMF } from "./helper-DIBUdU2j.js";
+import { m as mfLoaderUtilityClasses } from "./classes/index-C4jyh98a.js";
+import { L as LoadingError } from "../LoadingError/LoadingError-B3XRg-pT.js";
+import { M as MFLoaderRoot } from "./styles-CtS4rdXD.js";
+function getDivScritId(prefix, moduleId) {
+  const rotational_id = `${Math.round((/* @__PURE__ */ new Date()).getTime() / 1e3)}_rnd_${Math.round(
+    Math.random() * 1e3
+  )}`;
+  return {
+    // Esta propiedad es usada para asociarse al elemento div que retorna el componente MFLoader.
+    // Nota: este valor es importante porque cuando se requiera cargar el microfrontend, se utilizará la referencia id del elemento para crear un react render de la aplicación foranea.
+    /**
+     * Identificador único del contenedor HTML donde se renderizará el microfrontend.
+     */
+    divContainerId: `container_${prefix}_${moduleId}_${rotational_id}`,
+    /**
+     * Identificador único del script HTML asociado al microfrontend.
+     */
+    scriptId: `script_${moduleId}_${rotational_id}`,
+    /**
+     * Identificador único del módulo del microfrontend.
+     */
+    moduleId
+  };
+}
+function MFLoader(props) {
+  const { prefix, moduleId, cache = true, debug_port, dynamicMFStore, windowTools } = props;
+  const { hostThemeOptions, fnComponentsOverrides } = useHostTheme();
+  const { networkOperation } = useNetwork();
+  const environment = useEnvironment();
+  const hostTools = useHostTools();
+  const formatter = useFormatter();
+  const [statusLoader, setStatusLoader] = useState("progress");
+  const [loadingProgress, setLoadingProgress] = useState(-1);
+  const [divScript, setDivScript] = useState(getDivScritId(prefix, moduleId));
+  const { currentLocale } = useLocales();
+  const classes = mfLoaderUtilityClasses();
+  const isFirstRender = useFirstRender([moduleId]);
+  const final_host = environment.isLocalhost ? `https://localhost:${debug_port}` : `https://${window.location.host}/mf/${moduleId}`;
+  function cleanUp(dScript) {
+    try {
+      if (window[`unmount_${prefix}_${dScript.moduleId}`]) {
+        window[`unmount_${prefix}_${dScript.moduleId}`](dScript.divContainerId);
+      }
+    } catch (error) {
+    }
+    if (!cache) {
+      const script = document.getElementById(dScript.scriptId);
+      if (script) {
+        try {
+          document.head.removeChild(script);
+          delete window[`render_${prefix}_${dScript.moduleId}`];
+          delete window[`unmount_${prefix}_${dScript.moduleId}`];
+        } catch (error) {
+        }
+      }
+    }
+  }
+  const renderMicroFrontend = useCallback(
+    (newDScript) => {
+      try {
+        window[`render_${prefix}_${newDScript.moduleId}`](
+          newDScript.divContainerId,
+          { ...environment, isMicroFrontend: true, mfProps: { moduleId, debugPort: debug_port } },
+          hostTools,
+          currentLocale,
+          { hostThemeOptions, fnComponentsOverrides },
+          axiosOperation,
+          formatter,
+          dynamicMFStore,
+          windowTools
+        );
+      } catch (error) {
+      }
+    },
+    [hostThemeOptions, currentLocale, formatter]
+  );
+  const debouncedSetDivScript = useCallback(
+    debounce(
+      (newName) => {
+        const newDivScript = getDivScritId(prefix, newName);
+        if (newName !== divScript.moduleId) {
+          setDivScript({ ...newDivScript });
+        }
+      },
+      200
+    ),
+    [divScript]
+  );
+  useEffect(() => {
+    if (!isFirstRender) {
+      debouncedSetDivScript(moduleId + "");
+      if (moduleId !== divScript.moduleId) ;
+    }
+    return () => {
+    };
+  }, [moduleId]);
+  const tryAgainOnError = useCallback(() => {
+    window[`observable_${prefix}_${moduleId}`]?.tryAgain();
+  }, []);
+  useEffect(() => {
+    const dsNowScript = { ...divScript };
+    const observableDownload = (event, progress) => {
+      setLoadingProgress(progress);
+      setStatusLoader(event);
+    };
+    if (!window[`render_${prefix}_${moduleId}`]) {
+      let observableLoaderMF;
+      if (!window[`observable_${prefix}_${moduleId}`]) {
+        observableLoaderMF = new ObservableLoaderMF(
+          final_host,
+          dsNowScript.scriptId,
+          networkOperation,
+          !environment.isLocalhost
+        );
+        window[`observable_${prefix}_${moduleId}`] = observableLoaderMF;
+      } else {
+        observableLoaderMF = window[`observable_${prefix}_${moduleId}`];
+      }
+      observableLoaderMF.subscribe(observableDownload);
+    } else {
+      setStatusLoader("complete");
+    }
+    return () => {
+      window[`observable_${prefix}_${moduleId}`].unsubscribe(observableDownload);
+      cleanUp(dsNowScript);
+    };
+  }, [divScript]);
+  useEffect(() => {
+    if (statusLoader === "complete") {
+      renderMicroFrontend(divScript);
+    }
+  }, [statusLoader]);
+  return /* @__PURE__ */ jsxs(MFLoaderRoot, { id: divScript.divContainerId, className: classes.root, children: [
+    statusLoader === "progress" ? /* @__PURE__ */ jsx(ProggessLoadingMF, { loadingProgress }) : (
+      // <div>{networkProgress}</div>
+      null
+    ),
+    statusLoader === "error" ? /* @__PURE__ */ jsx(LoadingError, { status: statusLoader, action: tryAgainOnError }) : (
+      // <div>{networkProgress}</div>
+      null
+    )
+  ] });
+}
+export {
+  MFLoader as M
+};

package/components/MFLoader/classes/constants-CrKFBCVk.js

@@ -0,0 +1,4 @@
+const componentName = "M4LMFLoader";
+export {
+  componentName as c
+};

package/components/MFLoader/classes/index-C4jyh98a.js

@@ -0,0 +1,26 @@
+import { generateUtilityClasses, generateUtilityClass } from "@mui/material";
+import { unstable_composeClasses } from "@mui/base";
+import { c as componentName } from "./constants-CrKFBCVk.js";
+const mfLoaderClasses = generateUtilityClasses(componentName, [
+  /* elements */
+  "root",
+  "containerLinearProgress"
+  /* states or variants of elements */
+]);
+function getMFLoaderUtilityClass(slot) {
+  return generateUtilityClass(componentName, slot);
+}
+const mfLoaderUtilityClasses = () => {
+  const slots = {
+    root: ["root"],
+    containerLinearProgress: ["containerLinearProgress"]
+  };
+  const composedClasses = unstable_composeClasses(slots, getMFLoaderUtilityClass, {});
+  return {
+    ...composedClasses
+  };
+};
+export {
+  mfLoaderClasses as a,
+  mfLoaderUtilityClasses as m
+};

package/components/MFLoader/dictionary-CXND9TXx.js

@@ -0,0 +1,6 @@
+function getMFLoaderComponentsDictionary() {
+  return ["mf_loader"];
+}
+export {
+  getMFLoaderComponentsDictionary as g
+};

package/components/MFLoader/helper-DIBUdU2j.js

@@ -0,0 +1,115 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class ObservableLoaderMF {
+  constructor(host, scriptId, networkOperation, isRemote) {
+    __publicField(this, "host");
+    __publicField(this, "isRemote");
+    __publicField(this, "eventStatus");
+    // private prefix: string;
+    // private moduleId: string;
+    __publicField(this, "scriptId");
+    __publicField(this, "networkOperation");
+    __publicField(this, "subscribers");
+    this.host = host;
+    this.subscribers = [];
+    this.scriptId = scriptId;
+    this.networkOperation = networkOperation;
+    this.isRemote = isRemote;
+    this.eventStatus = "progress";
+    this.start = this.start.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+    this.unsubscribe = this.unsubscribe.bind(this);
+    this.notify = this.notify.bind(this);
+    this.tryAgain = this.tryAgain.bind(this);
+    setTimeout(this.start, 100);
+  }
+  tryAgain() {
+    if (this.eventStatus === "error") {
+      setTimeout(this.start, 100);
+      new Promise((resolve) => {
+        resolve("ok");
+      }).then(() => {
+        this.start();
+      });
+    }
+  }
+  //Metodo para arrancar la ejecución
+  async start() {
+    let percentCompleted = 0;
+    this.notify("progress", percentCompleted);
+    const manifest = await fetch(`${this.host}/manifest.json?rnd=${Math.random()}`).then((res) => res.json()).catch(() => {
+      setTimeout(() => this.notify("error", 0), 300);
+      return void 0;
+    });
+    if (!manifest) {
+      return;
+    }
+    percentCompleted = 10;
+    this.notify("progress", percentCompleted);
+    const urlFile = `${this.host}/${manifest["src/index.tsx"]["file"]}?rnd=${Math.random()}`;
+    const controller = new AbortController();
+    const ret = await this.networkOperation({
+      method: "GET",
+      endPoint: urlFile,
+      isRemote: this.isRemote,
+      headers: { "Content-Type": "application/json" },
+      // La propiedad es un método nativo de axios usado para conocer el estado descarga para una solicitud de red.
+      onDownloadProgress: (progressEvent) => {
+        try {
+          if (progressEvent.lengthComputable) {
+            percentCompleted = 10 + Math.round(progressEvent.loaded * 90 / progressEvent.total);
+          } else {
+            percentCompleted = 10 + progressEvent.loaded / 15e5 * 90;
+            if (percentCompleted > 95) percentCompleted = 95;
+          }
+        } catch (error) {
+        }
+        this.notify("progress", percentCompleted);
+      },
+      isExternalUrl: true,
+      responseType: "text",
+      signal: controller.signal
+    }).then(() => {
+      return "ok";
+    }).catch(() => {
+      this.notify("error", 0);
+      return "error";
+    });
+    if (ret == "ok") {
+      const script = document.createElement("script");
+      const startTime = (/* @__PURE__ */ new Date()).getTime();
+      script.id = this.scriptId;
+      script.crossOrigin = "";
+      script.type = "module";
+      script.src = urlFile || "";
+      script.onload = () => {
+        this.notify("complete", 100);
+      };
+      document.head.appendChild(script);
+      console.debug("Script appened", startTime);
+    }
+  }
+  // Método para suscribirse al objeto observable
+  subscribe(subscriber) {
+    this.subscribers.push(subscriber);
+    this.tryAgain();
+  }
+  // Método para cancelar la suscripción a objeto observable
+  unsubscribe(subscriber) {
+    const index = this.subscribers.indexOf(subscriber);
+    if (index !== -1) {
+      this.subscribers.splice(index, 1);
+    }
+  }
+  // Método para notificar a los suscriptores cuando algo cambie
+  notify(newEvent, progress) {
+    this.eventStatus = newEvent;
+    this.subscribers.forEach((subscriber) => {
+      setTimeout(() => subscriber(newEvent, progress), 1);
+    });
+  }
+}
+export {
+  ObservableLoaderMF as O
+};

package/components/MFLoader/index-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/components/MFLoader/styles-CtS4rdXD.js

@@ -0,0 +1,7 @@
+import { styled } from "@mui/material";
+const MFLoaderRoot = styled("div")(({ theme }) => ({
+  ...theme.components?.M4LMFLoader?.styleOverrides
+}));
+export {
+  MFLoaderRoot as M
+};

package/components/MFLoader/subcomponents/ProggessLoadingMF/index-D8tU4EJM.js

@@ -0,0 +1,16 @@
+import { jsx } from "react/jsx-runtime";
+import { a as mfLoaderClasses } from "../../classes/index-C4jyh98a.js";
+import { L as LinearProgress } from "../../../mui_extended/LinearProgress/index-CGgW8jq2.js";
+const ProggessLoadingMF = (props) => {
+  try {
+    const { loadingProgress } = props;
+    if (loadingProgress >= 0 && loadingProgress <= 100) {
+      return /* @__PURE__ */ jsx("div", { className: mfLoaderClasses.containerLinearProgress, children: /* @__PURE__ */ jsx(LinearProgress, { variant: "determinate", value: loadingProgress }) });
+    }
+  } catch (error) {
+  }
+  return null;
+};
+export {
+  ProggessLoadingMF as P
+};

package/components/NavLink/NavLink-DdBc-kD8.js

@@ -0,0 +1,33 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { NavLink as NavLink$1 } from "react-router-dom";
+import { u as useUtilityClasses } from "./classes/index-CGAMfugg.js";
+import { N as NavLinkRoot } from "./styles-DL9dFk6r.js";
+import { T as TEST_PROP_ID } from "../../test/constants_no_mock-CF-669v-.js";
+import { g as getNameDataTestId } from "./tests/utils-CHu-fVih.js";
+import { T as Typography } from "../mui_extended/Typography/Typography-C_rG8K21.js";
+const NavLink = (props) => {
+  const { children, text, skeletonWidth, skeletongHeight, ...others } = props;
+  const classes = useUtilityClasses();
+  return /* @__PURE__ */ jsx(
+    NavLinkRoot,
+    {
+      className: classes.root,
+      ...process.env.NODE_ENV !== "production" ? { [TEST_PROP_ID]: getNameDataTestId("root") } : {},
+      children: /* @__PURE__ */ jsx(NavLink$1, { ...others, children: /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          Typography,
+          {
+            variant: "action",
+            skeletonWidth,
+            skeletongHeight,
+            children: text
+          }
+        ),
+        children
+      ] }) })
+    }
+  );
+};
+export {
+  NavLink as N
+};

package/components/NavLink/classes/constant-C5HMQmiK.js

@@ -0,0 +1,4 @@
+const componentName = "M4LNavLink";
+export {
+  componentName as c
+};

package/components/NavLink/classes/index-CGAMfugg.js

@@ -0,0 +1,23 @@
+import { generateUtilityClasses, generateUtilityClass } from "@mui/material";
+import { unstable_composeClasses } from "@mui/base";
+import { c as componentName } from "./constant-C5HMQmiK.js";
+generateUtilityClasses(componentName, [
+  /* elements */
+  "root"
+  /* states or variants of elements */
+]);
+function getNavLinkClassesUtilityClass(slot) {
+  return generateUtilityClass(componentName, slot);
+}
+const useUtilityClasses = () => {
+  const slots = {
+    root: ["root"]
+  };
+  const composedClasses = unstable_composeClasses(slots, getNavLinkClassesUtilityClass, {});
+  return {
+    ...composedClasses
+  };
+};
+export {
+  useUtilityClasses as u
+};

package/components/NavLink/index-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/components/NavLink/styles-DL9dFk6r.js

@@ -0,0 +1,7 @@
+import { styled } from "@mui/material/styles";
+const NavLinkRoot = styled("div")(({ theme }) => ({
+  ...theme.components?.M4LNavLink?.styleOverrides
+}));
+export {
+  NavLinkRoot as N
+};

package/components/NavLink/tests/constants-9o3PPR1T.js

@@ -0,0 +1,4 @@
+const NAVLINK_PREFIX = "Navlink";
+export {
+  NAVLINK_PREFIX as N
+};

package/components/NavLink/tests/utils-CHu-fVih.js

@@ -0,0 +1,7 @@
+import { N as NAVLINK_PREFIX } from "./constants-9o3PPR1T.js";
+const getNameDataTestId = (KEY) => {
+  return `${NAVLINK_PREFIX}-${KEY}`;
+};
+export {
+  getNameDataTestId as g
+};

package/components/NoItemSelected/classes/constants-NX4P7zJx.js

@@ -0,0 +1,4 @@
+const componentName = "M4LNoItemSelected";
+export {
+  componentName as c
+};

package/components/NoItemSelected/classes/index-CGh0_XXI.js

@@ -0,0 +1,26 @@
+import { generateUtilityClasses, generateUtilityClass } from "@mui/material";
+import { unstable_composeClasses } from "@mui/base";
+import { c as componentName } from "./constants-NX4P7zJx.js";
+generateUtilityClasses(
+  componentName,
+  [
+    /* elements */
+    "root"
+    /* states or variants of elements */
+  ]
+);
+function getNoItemSelectedUtilityClass(slot) {
+  return generateUtilityClass(componentName, slot);
+}
+const useNoItemSelectedUtilityClasses = () => {
+  const slots = {
+    root: ["root"]
+  };
+  const composedClasses = unstable_composeClasses(slots, getNoItemSelectedUtilityClass, {});
+  return {
+    ...composedClasses
+  };
+};
+export {
+  useNoItemSelectedUtilityClasses as u
+};

package/components/NoItemSelected/dictionary-DhPDgHyg.js

@@ -0,0 +1,12 @@
+function getNoItemSelectedComponentsDictionary() {
+  return ["no_item_selected"];
+}
+const defaultNoItemSelectedDictionary = {
+  no_item_selected: {
+    message: "Please select a item to show detail"
+  }
+};
+export {
+  defaultNoItemSelectedDictionary as d,
+  getNoItemSelectedComponentsDictionary as g
+};