@m4l/components 0.2.21 → 0.2.24

package/components/areas/contexts/DynamicMFParmsContext/types.d.ts

@@ -1,7 +1,19 @@
 import { ReactNode } from 'react';
 import type { DynamicMFStore } from './store';
+/**
+ * Tipo de datos que representa los parámetros de un Microfrontend Dinámico.
+ */
 export declare type DynamicMFParameters = Record<string, any>;
+/**
+ * Props para el proveedor de parámetros de un Microfrontend Dinámico.
+ */
 export interface DynamicMFParmsProviderProps {
+    /**
+    * Almacén de estado para los parámetros de un Microfrontend Dinámico.
+    */
     store: DynamicMFStore;
+    /**
+     * Los componentes secundarios del proveedor de parámetros de un Microfrontend Dinámico.
+     */
     children: ReactNode;
 }

package/components/areas/contexts/WindowToolsMFContext/index.d.ts

@@ -1,6 +1,20 @@
 import React from 'react';
+/**
+ * Tipo que define la estructura de las props del contexto de WindowToolsMF.
+ */
 import { WindowToolsMFContextProps, WindowToolsMFProviderProps } from './types';
+/**
+ * Contexto utilizado para proporcionar herramientas relacionadas con la ventana a los componentes secundarios.
+ */
 declare const WindowToolsMFContext: React.Context<WindowToolsMFContextProps | null>;
+/**
+ * Componente proveedor que envuelve la aplicación y proporciona el contexto de WindowToolsMF a los componentes secundarios.
+ * @param props Las props del componente WindowToolsMFProvider.
+ * @returns El proveedor del contexto de WindowToolsMF.
+ */
 declare function WindowToolsMFProvider(props: WindowToolsMFProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Componente WindowToolsMFProvider memoizado.
+ */
 declare const MemonizedWindowToolsMFContext: React.MemoExoticComponent<typeof WindowToolsMFProvider>;
 export { WindowToolsMFProvider, WindowToolsMFContext, MemonizedWindowToolsMFContext };

package/components/areas/contexts/WindowToolsMFContext/types.d.ts

@@ -1,18 +1,69 @@
 import { ReactNode } from 'react';
 import type { CookieType, AreaWindowAction, ToastyOptions } from '../../types';
+/**
+ * Interfaz que define un conjunto de herramientas relacionadas con la ventana que pueden ser proporcionadas por el contexto WindowToolsMF.
+ */
 export interface WindowToolsMF {
+    /**
+   * Método para obtener una cookie específica por su ID.
+   * @param id El ID de la cookie que se desea obtener.
+   * @returns La cookie correspondiente si se encuentra, de lo contrario, undefined.
+   */
     getCookie: (id: string) => Record<string, any> | undefined;
+    /**
+   * Método para obtener el ID de la ventana actual.
+   * @returns El ID de la ventana actual.
+   */
     getWindowId: () => string;
+    /**
+    * Método para obtener todas las cookies de un tipo específico.
+    * @param type El tipo de cookie del cual se desean obtener todas las cookies.
+    * @returns Un objeto que contiene todas las cookies del tipo especificado.
+    */
     getCookies: (type: CookieType) => Record<string, any>;
+    /**
+    * Método para establecer las acciones de ventana para el área actual.
+    * @param newActions Las nuevas acciones de ventana que se desean establecer.
+    * @param version (Opcional) La versión de las acciones de ventana.
+    */
     setActions: (newActions: AreaWindowAction[], version?: string) => void;
+    /**
+    * Método para establecer una cookie específica.
+    * @param id El ID de la cookie que se desea establecer.
+    * @param type El tipo de cookie que se desea establecer.
+    * @param cookie El contenido de la cookie que se desea establecer.
+    */
     setCookie: (id: string, type: CookieType, cookie: Record<string, any>) => void;
+    /**
+    * Método para iniciar el indicador de progreso.
+    */
     startProgress: () => void;
+    /**
+    * Método para detener el indicador de progreso.
+    */
     stopProgress: () => void;
+    /**
+    * Método para mostrar una notificación toast.
+    * @param options Las opciones de configuración para la notificación toast.
+    */
     toast: (options: ToastyOptions) => void;
+    /**
+    * Método para cerrar la ventana actual.
+    */
     close: () => void;
+    /**
+     * Método para establecer la función de consulta de cierre de la ventana.
+     * @param fnQueryClose La función de consulta de cierre de la ventana que se desea establecer.
+     */
     setFnQueryClose: (fnQueryClose: () => void) => void;
 }
+/**
+ * Props del componente WindowToolsMFProvider que incluyen las herramientas de ventana proporcionadas por la interfaz WindowToolsMF.
+ */
 export interface WindowToolsMFProviderProps extends WindowToolsMF {
     children: ReactNode;
 }
+/**
+ * Props del contexto WindowToolsMF, excluyendo la prop children.
+ */
 export declare type WindowToolsMFContextProps = Omit<WindowToolsMFProviderProps, 'children'>;

package/components/areas/hooks/useAreas/{index.5da0bc90.js → index.b18fe111.js}

@@ -1,6 +1,6 @@
 import { useContext } from "react";
 import { useStore } from "zustand";
-import { A as AreasContext } from "../../contexts/AreasContext/index.055ab6e2.js";
+import { A as AreasContext } from "../../contexts/AreasContext/index.3e3d8c62.js";
 function useAreasStore(selector, equalityFn) {
   const context = useContext(AreasContext);
   if (!context)

package/components/areas/types.d.ts

@@ -5,37 +5,95 @@ import type { MenuAction } from '../mui_extended';
 import { LayoutItem } from '../GridLayout';
 export declare type WindowActionType = 'main' | 'allways' | 'normal';
 export interface AreaWindowAction extends MenuAction {
+    /**
+     * Tipo de visibilidad de la acción de ventana.
+     */
     visibility: WindowActionType;
+    /**
+     * Clave única de la acción de ventana.
+     */
     key: string;
+    /**
+     * Etiqueta opcional para la acción de ventana.
+     */
     tag?: any;
+    /**
+  * Clase CSS opcional para la acción de ventana.
+  */
     className?: string;
 }
+/**
+ * Tipo que representa el tipo de ventana: microfrontend o componente.
+ */
 export declare type WinType = 'microfrontend' | 'component';
+/**
+ * Tipo que representa el tipo de emergencia de la ventana: diseño, popup o modal.
+ */
 export declare type EmergeType = 'layout' | 'popup' | 'modal';
+/**
+ * Tipo que representa el tipo de apertura de la ventana: normal o maximizado.
+ */
 export declare type OpenType = 'normal' | 'maximized';
+/**
+ * Propiedades base de un microfrontend.
+ */
 export interface MFBaseProps {
+    /**
+    * Puerto de depuración utilizado para cargar el microfrontend en entornos locales.
+    */
     debug_port: number;
+    /**
+     * Indica si se debe almacenar en caché el microfrontend para futuros usos.
+     */
     cache?: boolean;
+    /**
+    * Prefijo utilizado para identificar los microfrontends. Por ejemplo, "m4labs", "guardian", etc.
+    */
     prefix: string;
 }
 export declare type JSX_REACT_NODE = ((props?: any) => JSX.Element) | ReactNode;
+/**
+ * Tipo que representa el tipo de cookie: ventana o módulo.
+ */
 export declare type CookieType = 'window' | 'module';
+/**
+ * Objeto que contiene las cookies de un módulo y de una ventana.
+ */
 export declare type Cookies = {
     moduleCookies: Record<string, any>;
     windowCookies: Record<string, any>;
 };
+/**
+ * Tipo que representa el estado de la ventana: inicialización, carga, cargado o error.
+ */
 export declare type WindowStatus = 'init' | 'loading' | 'loaded' | 'error';
+/**
+ * Tipo que representa el tipo de tostada: éxito, información, advertencia o error.
+ */
 export declare type ToastyType = 'success' | 'info' | 'warning' | 'error';
+/**
+ * Objeto que representa una tostada.
+ */
 export declare type Toasty = {
+    /** Identificador único de la tostada. */
     id: number;
+    /** Duración en milisegundos antes de que la tostada desaparezca. */
     timeoutMs: number;
+    /** Mensaje que se muestra en la tostada. */
     type: ToastyType;
+    /** Momento en que se inició la tostada en milisegundos desde la época. */
     message: string;
+    /** Porcentaje de ejecución de la tostada. */
     timeStart: number;
+    /** Temporizador utilizado para controlar el tiempo de vida de la tostada. */
     percentExecuted: number;
+    /** Identificador de la tostada que debe ser reemplazada. */
     timer?: ReturnType<typeof setInterval>;
     replaceMeId?: string;
 };
+/**
+ * Opciones para configurar una tostada.
+ */
 export interface ToastyOptions extends Pick<Toasty, 'message' | 'type' | 'replaceMeId'> {
     timeoutMs?: number;
 }
@@ -50,9 +108,19 @@ export declare type WindowState = {
      */
     loading: boolean;
     version?: string;
+    /**
+    * Acciones del módulo.
+    */
     moduleActions: AreaWindowAction[];
     cookies: Cookies;
+    /**
+   * Lista de tostadas.
+   */
     toasties: Toasty[];
+    /**
+ * Hash que mapea el identificador de la tostada con su respectiva información.
+
+ */
     hashToasties: Record<number, Toasty>;
     toastyCount: number;
     /**
@@ -61,10 +129,22 @@ export declare type WindowState = {
      */
     fnQueryClose?: () => void;
 };
+/**
+ * Opciones para la ventana.
+ */
 export declare type WindowOptions = {
+    /**
+    * Indica si se permitirá persistir las cookies.
+    */
     allowPersistCookies: boolean;
 };
+/**
+ * Propiedades base para una ventana en la aplicación.
+ */
 export interface WindowBaseProps {
+    /**
+    * Tipo de ventana ('microfrontend' o 'component').
+    */
     winType: WinType;
     emergeType: EmergeType;
     openType?: OpenType;

package/components/commercial/AppBarCommercial/classes/constants.d.ts

@@ -0,0 +1 @@
+export declare const componentName = "M4LAppBarCommercial";

package/components/commercial/AppBarCommercial/classes/index.d.ts

@@ -0,0 +1,4 @@
+import { AppBarComercialClassesType } from './types';
+export declare const appBarComercialClasses: AppBarComercialClassesType;
+export declare function getAppBarComercialUtilityClass(slot: string): string;
+export declare const useAppBarComercialUtilityClasses: () => Record<"root", string>;

package/components/commercial/AppBarCommercial/classes/types.d.ts

@@ -0,0 +1,6 @@
+import { useAppBarComercialUtilityClasses } from ".";
+export interface AppBarComercialClassesType {
+    root: string;
+}
+export declare type appBarComercialClassesKey = keyof AppBarComercialClassesType;
+export declare type Classes = ReturnType<typeof useAppBarComercialUtilityClasses>;

package/components/commercial/AppBarCommercial/index.c5022fdd.js

@@ -0,0 +1,30 @@
+import { generateUtilityClasses, styled } from "@mui/material";
+import { unstable_composeClasses } from "@mui/base";
+import { g as getComponentUtilityClass } from "../../../utils/index.de903261.js";
+import { jsx } from "react/jsx-runtime";
+const componentName = "M4LAppBarCommercial";
+generateUtilityClasses(componentName, [
+  "root"
+]);
+const useAppBarComercialUtilityClasses = () => {
+  const slots = {
+    root: ["root"]
+  };
+  return unstable_composeClasses(slots, getComponentUtilityClass(componentName), {});
+};
+const AppBarComercialRoot = styled("div")(({ theme }) => ({
+  ...theme.components?.M4LAppBarCommercial?.styleOverrides
+}));
+const AppBarComercial = (props) => {
+  const {
+    children
+  } = props;
+  const classes = useAppBarComercialUtilityClasses();
+  return /* @__PURE__ */ jsx(AppBarComercialRoot, {
+    className: classes.root,
+    children
+  });
+};
+export {
+  AppBarComercial as A
+};

package/components/commercial/AppBarCommercial/index.d.ts

@@ -0,0 +1,2 @@
+import { AppBarComercialProps } from './types';
+export declare const AppBarComercial: (props: AppBarComercialProps) => import("react/jsx-runtime").JSX.Element;

package/components/commercial/AppBarCommercial/types.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from "react";
+export interface AppBarComercialProps {
+    children: ReactNode;
+}

package/components/commercial/HamburgerMenu/HamburgerMenu.d.ts

@@ -0,0 +1,29 @@
+import { HamburguerMenuProps } from './types';
+/**
+ * Componente HamburgerMenu
+ *
+ * Este componente representa un menú de hamburguesa interactivo que se puede mostrar u ocultar.
+ *
+ * @component
+ * @example
+ * // Ejemplo de uso:
+ * <HamburgerMenu />
+ */
+/**
+ * Función para manejar la visibilidad alternada.
+ *
+ * Esta función se utiliza para cambiar el estado de visibilidad entre visible e invisible.
+ * Se asume que `setVisible` es una función que maneja el estado de visibilidad en algún componente.
+ *
+ * @function
+ * @name handlerOnVisible
+ * @returns {void}
+ *
+ * @example
+ * // Ejemplo de uso:
+ * const [visible, setVisible] = useState(false);
+ * const toggleVisibility = () => {
+ *   setVisible(val => !val);
+ * };
+ */
+export declare const HamburgerMenu: (props: HamburguerMenuProps) => import("react/jsx-runtime").JSX.Element;

package/components/commercial/HamburgerMenu/classes/constants.d.ts

@@ -0,0 +1 @@
+export declare const componentName = "M4LHamburgerMenuCommercial";

package/components/commercial/HamburgerMenu/classes/index.d.ts

@@ -0,0 +1,7 @@
+import { HamburgerMenuComercialClassesType } from './type';
+export declare const hamburgerMenuComercialClasses: HamburgerMenuComercialClassesType;
+export declare function getHamburgerMenuComercialClassesUtilityClass(slot: string): string;
+export declare const useHamburgerMenuComercialUtilityClasses: () => {
+    root: string;
+    ImageLogo: string;
+};

package/components/commercial/HamburgerMenu/classes/type.d.ts

@@ -0,0 +1,7 @@
+import { useHamburgerMenuComercialUtilityClasses } from ".";
+export interface HamburgerMenuComercialClassesType {
+    root: string;
+    ImageLogo: string;
+}
+export declare type HamburgerMenuComercialClassesKey = keyof HamburgerMenuComercialClassesType;
+export declare type Classes = ReturnType<typeof useHamburgerMenuComercialUtilityClasses>;

package/components/commercial/HamburgerMenu/index.d.ts

@@ -0,0 +1,2 @@
+export { HamburgerMenu } from './HamburgerMenu';
+export type { MenuDataType } from '../../SideBar/types';

package/components/commercial/HamburgerMenu/test/constants.d.ts

@@ -0,0 +1 @@
+export declare const HAMBURGER_MENU_PREFIX = "M4LHamburgerMenu";

package/components/commercial/HamburgerMenu/test/utils.d.ts

@@ -0,0 +1,2 @@
+import { HamburgerMenuComercialClassesKey } from "../classes/type";
+export declare const getNameDataTestId: (KEY: HamburgerMenuComercialClassesKey) => string;

package/components/commercial/HamburgerMenu/types.d.ts

@@ -0,0 +1,5 @@
+import { MenuDataType } from ".";
+export interface HamburguerMenuProps {
+    data: Array<MenuDataType>;
+    itemClick: (item: MenuDataType) => void;
+}

package/components/commercial/SectionCommercial/classes/constants.d.ts

@@ -0,0 +1 @@
+export declare const componentName = "M4LSectionCommercial";

package/components/commercial/SectionCommercial/classes/index.d.ts

@@ -0,0 +1,5 @@
+import { AppBarComercialClassesType } from './types';
+import { OnwerState } from './../types';
+export declare const appBarComercialClasses: AppBarComercialClassesType;
+export declare function getAppBarComercialUtilityClass(slot: string): string;
+export declare const useAppBarComercialUtilityClasses: (ownerState: OnwerState) => Record<"root", string>;

package/components/commercial/SectionCommercial/classes/types.d.ts

@@ -0,0 +1,9 @@
+import { useAppBarComercialUtilityClasses } from ".";
+export interface AppBarComercialClassesType {
+    root: string;
+    fullWidth: string;
+    boxed: string;
+    columnReverse: string;
+}
+export declare type appBarComercialClassesKey = keyof AppBarComercialClassesType;
+export declare type Classes = ReturnType<typeof useAppBarComercialUtilityClasses>;

package/components/commercial/SectionCommercial/index.d.ts

@@ -0,0 +1,2 @@
+import { SectionComercialProps } from './types';
+export declare const SectionCommercial: (props: SectionComercialProps) => import("react/jsx-runtime").JSX.Element;

package/components/commercial/SectionCommercial/types.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+import { StackProps } from "../../mui_extended";
+export interface SectionComercialProps extends StackProps {
+    children: ReactNode;
+    contentWith?: 'fullWidth' | 'boxed';
+    columnReverse?: boolean;
+}
+export interface OnwerState extends Pick<SectionComercialProps, 'contentWith' | 'columnReverse'> {
+}

package/components/commercial/TopBar/TopBar.d.ts

@@ -0,0 +1,16 @@
+import { TopBarProps } from './type';
+/**
+ *
+ * @param {TopBarProps} props  - Propiedades del componente.
+ * @param {TopBarMenuDataType} props.DataMenu - Datos para generar la quema de datos en el componente
+ * @param {string} props.dataTestId - Valor para el testeo
+ *
+ * @returns componente de navegación
+ *
+ * @example
+ * <TopBar
+    DataMenu={MENUDATA_TYPE}
+    dataTestId=""
+    />
+ */
+export declare const TopBar: (props: TopBarProps) => import("react/jsx-runtime").JSX.Element;

package/components/commercial/TopBar/classes/constants.d.ts

@@ -0,0 +1 @@
+export declare const componentName = "M4LTopBar";

package/components/commercial/TopBar/classes/index.d.ts

@@ -0,0 +1,12 @@
+import { TopBarClassesType } from './types';
+export declare const TopBarClasses: TopBarClassesType;
+export declare function getTopBarClassesUtilityClass(): {
+    root: string;
+    ContainerImageComercial: string;
+    SimplebarComercial: string;
+    ItemRoot: string;
+    ItemSelect: string;
+    ContainerAccordion: string;
+    ContainerAccordionCase1: string;
+    IconAndButton: string;
+};

package/components/commercial/TopBar/classes/types.d.ts

@@ -0,0 +1,12 @@
+export interface TopBarClassesType {
+    root: string;
+    ContainerImageComercial: string;
+    SimplebarComercial: string;
+    ItemRoot: string;
+    ItemSelect: string;
+    ContainerAccordion: string;
+    ContainerAccordionCase1: string;
+    IconAndButton: string;
+    IsActive: string;
+}
+export declare type TopBarClassesKey = keyof TopBarClassesType;

package/components/commercial/TopBar/component/ConteinItem/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description Componente que se encarga de crear la estructura para el menu de navegación
+ * @returns
+ */
+export declare const ConteinItem: () => import("react/jsx-runtime").JSX.Element;

package/components/commercial/TopBar/component/ConteinItem/subcomponets/NavItem/index.d.ts

@@ -0,0 +1,12 @@
+import { NavItemRootProps } from "./types";
+/**
+ * @description Componente que es el NavItemRoot que es el boton con la posibilidad de tener un accordion
+ * @param props - Props de el componente NavItemRoot
+ * @param {TopBarMenuDataType} props.itemRootData - Array de tipo TopBarMenuDataType
+ *
+ *
+ * @returns Boton con o sin accordion
+ *
+ * @example <NavItemRoot key={group.id} itemRootData={group} />
+ */
+export declare const NavItemRoot: (props: NavItemRootProps) => import("react/jsx-runtime").JSX.Element;

package/components/commercial/TopBar/component/ConteinItem/subcomponets/NavItem/subcomponents/ArrowIcon/index.d.ts

@@ -0,0 +1,2 @@
+import { ArrowIconProps } from './types';
+export declare function ArrowIcon(props: ArrowIconProps): import("react/jsx-runtime").JSX.Element;

package/components/commercial/TopBar/component/ConteinItem/subcomponets/NavItem/subcomponents/ArrowIcon/types.d.ts

@@ -0,0 +1,4 @@
+export interface ArrowIconProps {
+    openState: boolean;
+    className?: string;
+}

package/components/commercial/TopBar/component/ConteinItem/subcomponets/NavItem/types.d.ts

@@ -0,0 +1,4 @@
+import { MenuDataType } from "../../../../../../SideBar";
+export interface NavItemRootProps {
+    itemRootData: MenuDataType;
+}

package/components/commercial/TopBar/context/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { TopBarProviderProps, TopBarProviderValue } from "./type";
+/**
+ * @param TopBarContext  Creación de variable de contexto para compartir el estado y almacenar una configuración inicial
+ */
+declare const TopBarContext: import("react").Context<TopBarProviderValue>;
+/**
+ *
+ * @param {TopBarProviderProps} props - Propiedades del componente
+ * @param {TopBarProviderValue} props.value - Llama para los estilos de las classes y contiene los atributos de TopBarProps.
+ * @param {ReactNode} props.children - Recibe Childrens
+ *
+ * @returns
+ */
+declare const TopBarProvider: (props: TopBarProviderProps) => import("react/jsx-runtime").JSX.Element;
+export { TopBarProvider, TopBarContext };

package/components/commercial/TopBar/context/type.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+import { Classes, TopBarProps } from "../type";
+/**
+ * @interface TopBarProviderValue Hereda propiedades de TopBarProps y almacena classes
+ */
+export interface TopBarProviderValue extends TopBarProps {
+    classes: Classes;
+}
+export interface TopBarProviderProps {
+    value: TopBarProviderValue;
+    children: ReactNode;
+}

package/components/commercial/TopBar/hook/topBarContext/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @type Variable que almacena el uso del estado y ayuda a evitar prop drilling
+ */
+declare const useTopBar: () => import("../../context/type").TopBarProviderValue;
+export default useTopBar;