@m4l/layouts 9.1.8 → 9.1.10-beta.1

package/components/ModuleDetailTabs/useModuleDatailTabs.d.ts

@@ -0,0 +1,308 @@
+import { ModuleDetailTabContent, ModuleDetailTabsProps } from './types';
+/**
+ * Componente para mostrar un listado de tabs y contenido en un MasterDetail, basado en las props
+ */
+export declare function useModuleDetailTabs<T extends Record<string, any> = Record<string, any>, K extends Record<string, any> = Record<string, any>>(props: ModuleDetailTabsProps<T, K>): {
+    conditionNoMasterSelection: boolean;
+    currentTab: string;
+    detailData: any;
+    endPointData: any;
+    hasPrivilegeDetail: boolean;
+    finalTabs: {
+        unmountable: boolean;
+        icon: import("react/jsx-runtime").JSX.Element | undefined;
+        label: string | undefined;
+        value: string;
+        tabContent: import('react').FunctionComponent<any>;
+        componentProps?: Omit<any, keyof ModuleDetailTabContent<T_1, K_1>> | undefined;
+        dictionaryId?: string;
+        size?: Extract<import('@m4l/styles').Sizes, "small" | "medium"> | undefined;
+        children?: null | undefined;
+        ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
+        title?: string | undefined;
+        component?: React.ElementType | undefined;
+        id?: string | undefined;
+        disabled?: boolean | undefined;
+        action?: React.Ref<import('@mui/material').ButtonBaseActions> | undefined;
+        hidden?: boolean | undefined;
+        color?: Extract<import('@m4l/styles').ComponentPalletColor, "default"> | undefined;
+        content?: string | undefined;
+        style?: React.CSSProperties | undefined;
+        translate?: "yes" | "no" | undefined;
+        urlIcon?: string | undefined;
+        lang?: string | undefined;
+        slot?: string | undefined;
+        dir?: string | undefined;
+        className?: string | undefined;
+        classes?: (Partial<import('@mui/material').TabClasses> & Partial<import('@mui/material').ClassNameMap<never>>) | undefined;
+        sx?: import('@mui/system').SxProps<import('@mui/material').Theme> | undefined;
+        key?: import('react').Key | null | undefined;
+        defaultChecked?: boolean | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        accessKey?: string | undefined;
+        autoFocus?: boolean | undefined;
+        contentEditable?: (boolean | "false" | "true") | "inherit" | "plaintext-only" | undefined;
+        contextMenu?: string | undefined;
+        draggable?: (boolean | "false" | "true") | undefined;
+        nonce?: string | undefined;
+        spellCheck?: (boolean | "false" | "true") | undefined;
+        tabIndex?: NonNullable<React.HTMLAttributes<any>["tabIndex"]> | undefined;
+        radioGroup?: string | undefined;
+        role?: import('react').AriaRole | undefined;
+        about?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        prefix?: string | undefined;
+        property?: string | undefined;
+        rel?: string | undefined;
+        resource?: string | undefined;
+        rev?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCapitalize?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "on" | "off" | undefined;
+        inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+        is?: string | undefined;
+        "aria-activedescendant"?: string | undefined;
+        "aria-atomic"?: (boolean | "false" | "true") | undefined;
+        "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+        "aria-braillelabel"?: string | undefined;
+        "aria-brailleroledescription"?: string | undefined;
+        "aria-busy"?: (boolean | "false" | "true") | undefined;
+        "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-colcount"?: number | undefined;
+        "aria-colindex"?: number | undefined;
+        "aria-colindextext"?: string | undefined;
+        "aria-colspan"?: number | undefined;
+        "aria-controls"?: string | undefined;
+        "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+        "aria-describedby"?: string | undefined;
+        "aria-description"?: string | undefined;
+        "aria-details"?: string | undefined;
+        "aria-disabled"?: (boolean | "false" | "true") | undefined;
+        "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+        "aria-errormessage"?: string | undefined;
+        "aria-expanded"?: (boolean | "false" | "true") | undefined;
+        "aria-flowto"?: string | undefined;
+        "aria-grabbed"?: (boolean | "false" | "true") | undefined;
+        "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+        "aria-hidden"?: (boolean | "false" | "true") | undefined;
+        "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+        "aria-keyshortcuts"?: string | undefined;
+        "aria-label"?: string | undefined;
+        "aria-labelledby"?: string | undefined;
+        "aria-level"?: number | undefined;
+        "aria-live"?: "off" | "assertive" | "polite" | undefined;
+        "aria-modal"?: (boolean | "false" | "true") | undefined;
+        "aria-multiline"?: (boolean | "false" | "true") | undefined;
+        "aria-multiselectable"?: (boolean | "false" | "true") | undefined;
+        "aria-orientation"?: "horizontal" | "vertical" | undefined;
+        "aria-owns"?: string | undefined;
+        "aria-placeholder"?: string | undefined;
+        "aria-posinset"?: number | undefined;
+        "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-readonly"?: (boolean | "false" | "true") | undefined;
+        "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+        "aria-required"?: (boolean | "false" | "true") | undefined;
+        "aria-roledescription"?: string | undefined;
+        "aria-rowcount"?: number | undefined;
+        "aria-rowindex"?: number | undefined;
+        "aria-rowindextext"?: string | undefined;
+        "aria-rowspan"?: number | undefined;
+        "aria-selected"?: (boolean | "false" | "true") | undefined;
+        "aria-setsize"?: number | undefined;
+        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+        "aria-valuemax"?: number | undefined;
+        "aria-valuemin"?: number | undefined;
+        "aria-valuenow"?: number | undefined;
+        "aria-valuetext"?: string | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined;
+        onCopy?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+        onCopyCapture?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+        onCut?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+        onCutCapture?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+        onPaste?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+        onPasteCapture?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+        onCompositionEnd?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionStart?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionUpdate?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+        onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+        onFocus?: import('react').FocusEventHandler<HTMLDivElement> | undefined;
+        onFocusCapture?: import('react').FocusEventHandler<HTMLDivElement> | undefined;
+        onBlur?: import('react').FocusEventHandler<HTMLDivElement> | undefined;
+        onBlurCapture?: import('react').FocusEventHandler<HTMLDivElement> | undefined;
+        onChange?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onChangeCapture?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onBeforeInput?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onBeforeInputCapture?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onInput?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onInputCapture?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onReset?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onResetCapture?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onSubmit?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onSubmitCapture?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onInvalid?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onInvalidCapture?: import('react').FormEventHandler<HTMLDivElement> | undefined;
+        onLoad?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onError?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onErrorCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onKeyDown?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+        onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+        onKeyPress?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+        onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+        onKeyUp?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+        onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+        onAbort?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onAbortCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onCanPlay?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onCanPlayCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onCanPlayThrough?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onDurationChange?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onDurationChangeCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onEmptied?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onEmptiedCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onEncrypted?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onEncryptedCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onEnded?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onEndedCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadedData?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadedDataCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadedMetadata?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadStart?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onLoadStartCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onPause?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onPauseCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onPlay?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onPlayCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onPlaying?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onPlayingCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onProgress?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onProgressCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onRateChange?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onRateChangeCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onResize?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onResizeCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onSeeked?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onSeekedCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onSeeking?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onSeekingCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onStalled?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onStalledCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onSuspend?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onSuspendCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onTimeUpdate?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onVolumeChange?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onWaiting?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onWaitingCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onAuxClick?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onAuxClickCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onClick?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onClickCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onContextMenu?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onContextMenuCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onDoubleClick?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onDoubleClickCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onDrag?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragEnd?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragEndCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragEnter?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragEnterCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragExit?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragExitCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragLeave?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragLeaveCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragOver?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragOverCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragStart?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDragStartCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDrop?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onDropCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+        onMouseDown?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseDownCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseEnter?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseLeave?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseMove?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseMoveCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseOut?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseOutCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseOver?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseOverCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseUp?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onMouseUpCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+        onSelect?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onSelectCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+        onTouchCancel?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchCancelCapture?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchEnd?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchEndCapture?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchMove?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchMoveCapture?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchStart?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+        onTouchStartCapture?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+        onPointerDown?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerDownCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerMove?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerMoveCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerUp?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerUpCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerCancel?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerCancelCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerEnter?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerLeave?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerOver?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerOverCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerOut?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onPointerOutCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onGotPointerCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onLostPointerCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+        onScroll?: import('react').UIEventHandler<HTMLDivElement> | undefined;
+        onScrollCapture?: import('react').UIEventHandler<HTMLDivElement> | undefined;
+        onWheel?: import('react').WheelEventHandler<HTMLDivElement> | undefined;
+        onWheelCapture?: import('react').WheelEventHandler<HTMLDivElement> | undefined;
+        onAnimationStart?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationEnd?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationIteration?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+        onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+        onTransitionEnd?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+        onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+        centerRipple?: boolean | undefined;
+        disableRipple?: boolean | undefined;
+        disableTouchRipple?: boolean | undefined;
+        focusRipple?: boolean | undefined;
+        focusVisibleClassName?: string | undefined;
+        LinkComponent?: React.ElementType | undefined;
+        onFocusVisible?: React.FocusEventHandler<any> | undefined;
+        TouchRippleProps?: Partial<import('@mui/material/ButtonBase/TouchRipple').TouchRippleProps> | undefined;
+        touchRippleRef?: React.Ref<import('@mui/material/ButtonBase/TouchRipple').TouchRippleActions> | undefined;
+        disableFocusRipple?: boolean | undefined;
+        dataTestId?: string | undefined;
+        iconPosition?: ("top" | "bottom" | "start" | "end") | undefined;
+        wrapped?: boolean | undefined;
+    }[];
+    handleChangeTab: (newValue: string) => void;
+};

package/components/ModuleDetailTabs/useModuleDatailTabs.js

@@ -0,0 +1,86 @@
+import { jsx } from "react/jsx-runtime";
+import { useState, useMemo, useEffect } from "react";
+import { u as useMasterDetail } from "../../hooks/useMasterDetail/index.js";
+import { useModuleDictionary, useNetwork } from "@m4l/core";
+import { useWindowToolsMF, ObjectLogs, Icon } from "@m4l/components";
+function useModuleDetailTabs(props) {
+  const { tabs, defaultTab, urlAssetsPrefix, objectLogsProps, getEndPoint } = props;
+  const [currentTab, setCurrentTab] = useState(defaultTab);
+  const [detailData, setDetailData] = useState(void 0);
+  const [endPointData, setEndPointData] = useState(void 0);
+  const [hasPrivilegeDetail, setHasPrivilegeDetail] = useState(true);
+  const { masterSelection } = useMasterDetail();
+  const { getLabel } = useModuleDictionary();
+  const { startProgress, stopProgress } = useWindowToolsMF();
+  const { networkOperation } = useNetwork();
+  const handleChangeTab = (newValue) => {
+    setCurrentTab(newValue);
+  };
+  const finalTabs = useMemo(() => {
+    if (masterSelection === void 0 || masterSelection.length === 0) {
+      return [];
+    }
+    const arrTabs = [...tabs];
+    if (objectLogsProps) {
+      arrTabs.push({
+        ...objectLogsProps,
+        value: "objectLogs",
+        tabContent: ObjectLogs,
+        unmountable: false,
+        componentProps: {
+          resourceId: objectLogsProps.resourceId.toString(),
+          objectId: objectLogsProps.getObjectId(masterSelection[0])
+        }
+      });
+    }
+    return arrTabs.map((tab) => ({
+      ...tab,
+      unmountable: tab.unmountable === void 0 ? true : tab.unmountable,
+      icon: typeof tab.icon === "string" ? /* @__PURE__ */ jsx(Icon, { src: `${urlAssetsPrefix}/${tab.icon}` }) : tab.icon,
+      label: tab.dictionaryId ? getLabel(tab.dictionaryId) : void 0
+    }));
+  }, [masterSelection, tabs, objectLogsProps, urlAssetsPrefix, getLabel]);
+  useEffect(() => {
+    if (masterSelection === void 0 || masterSelection.length === 0) {
+      return;
+    }
+    setDetailData(masterSelection[0]);
+  }, [masterSelection]);
+  const conditionNoMasterSelection = masterSelection === void 0 || masterSelection.length === 0;
+  useEffect(() => {
+    if (!getEndPoint) {
+      return;
+    }
+    if (masterSelection === void 0 || masterSelection.length === 0) {
+      return;
+    }
+    networkOperation({
+      options: {
+        startProgress,
+        stopProgress
+      },
+      ...getEndPoint(masterSelection[masterSelection.length - 1])
+    }).then((response) => {
+      {
+        setHasPrivilegeDetail(true);
+        setEndPointData(response);
+      }
+    }).catch((error) => {
+      if (error.status === 403) {
+        setHasPrivilegeDetail(false);
+      }
+    });
+  }, [masterSelection, startProgress, stopProgress, networkOperation, getEndPoint]);
+  return {
+    conditionNoMasterSelection,
+    currentTab,
+    detailData,
+    endPointData,
+    hasPrivilegeDetail,
+    finalTabs,
+    handleChangeTab
+  };
+}
+export {
+  useModuleDetailTabs as u
+};

package/components/index.d.ts

@@ -1,3 +1,4 @@
 export { MFNoAuthApp } from './MFNoAuthApp';
-export { MFHostApp } from './MFHostApp';
-export type { ByHostProps } from './MFHostApp/types';
+export { MFHostApp } from './MFHostApp/MFHostApp';
+export * from './MFHostApp';
+export * from './ModuleDetailTabs';

package/contexts/AuthContext/index.d.ts

@@ -2,10 +2,6 @@ import { AuthProviderProps, SessionContextType } from './types';
 declare const AuthContext: import('react').Context<SessionContextType | null>;
 /**
  * Proveedor de autenticación
- * @author Juan Escobar - automatic
- * @createdAt 2024-10-09 19:56:26 - automatic
- * @updatedAt 2024-10-09 20:00:30 - automatic
- * @updatedUser Juan Escobar - automatic
  */
 declare function AuthProvider(props: AuthProviderProps): import("react/jsx-runtime").JSX.Element;
 export { AuthContext, AuthProvider };

package/hooks/index.d.ts

@@ -1,3 +1,4 @@
 export * from './useMasterDetail';
 export * from './useAuth';
 export * from './useModule';
+export * from './useDynamicAccordions';

package/hooks/useAuth/index.d.ts

@@ -1,9 +1,5 @@
 /**
  * Hook para obtener el contexto de autenticación
- * @author Juan Escobar - automatic
- * @createdAt 2024-10-09 19:56:26 - automatic
- * @updatedAt 2024-10-09 20:00:30 - automatic
- * @updatedUser Juan Escobar - automatic
  */
 export declare const useAuth: () => import('../../contexts/AuthContext/types').SessionContextType;
 export default useAuth;

package/hooks/useDynamicAccordions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useDynamicAccordions';
+export type { useDynamicAccordionsProps, ConfigDynamicAccordion as DynamicAccordion, DynamicAccordionValue } from './types';

package/hooks/useDynamicAccordions/index.js

@@ -0,0 +1 @@
+

package/hooks/useDynamicAccordions/types.d.ts

@@ -0,0 +1,42 @@
+import { AccordionProps } from '@m4l/components';
+import { ModuleDetailTabContent } from '../../components/ModuleDetailTabs';
+export type DynamicAccordionValue<T extends any = any, K extends any = any> = (data: T, endPointData?: K) => string | React.ReactNode;
+export interface ConfigDynamicAccordion<T extends any = any, K extends any = any> {
+    /**
+     * "icon": Icono de la propiedad
+     */
+    icon?: string;
+    /**
+     * "dictionaryId": Id de la propiedad en el diccionario para mostrar en el label
+     */
+    dictionaryId: string;
+    /**
+     * "accordionProps" Propiedades del accordion
+     */
+    accordionProps?: AccordionProps['accordionProps'];
+    /**
+     * "properties": Propiedades que se ven en el accordion
+     */
+    properties: {
+        /**
+         * "icon": Icono de la propiedad
+         */
+        icon?: string | React.ReactNode;
+        /**
+         * "dictionaryId": Id de la propiedad en el diccionario para mostrar en el label
+         */
+        dictionaryId: string;
+        /**
+         * "getValue": Función que se encarga de obtener el valor de la propiedad
+         */
+        getValue: DynamicAccordionValue<T, K>;
+        /**
+         * "privilegeToView": Si se requiere un privilegio para ver el valor
+         */
+        privilegeToView?: string;
+    }[];
+}
+export interface useDynamicAccordionsProps<T extends any = any, K extends any = any> {
+    configDynamicAccordions: ConfigDynamicAccordion<T, K>[];
+}
+export type useBaseDynamicAccordionsProps<T extends any = any, K extends any = any> = useDynamicAccordionsProps<T, K> & ModuleDetailTabContent;

package/hooks/useDynamicAccordions/useBaseAccordions.d.ts

@@ -0,0 +1,5 @@
+import { useBaseDynamicAccordionsProps } from './types';
+/**
+ * Hook que se encarga de gestionar los accordions del detalle de inventario
+ */
+export declare function useBaseAccordions(props: useBaseDynamicAccordionsProps): import("react/jsx-runtime").JSX.Element[];

package/hooks/useDynamicAccordions/useBaseAccordions.js

@@ -0,0 +1,38 @@
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Accordion, PropertyValue } from "@m4l/components";
+import { useModuleDictionary } from "@m4l/core";
+function useBaseAccordions(props) {
+  const { data, endPointData, configDynamicAccordions: accordions } = props;
+  const { getLabel } = useModuleDictionary();
+  const AccordionsComponents = useMemo(() => {
+    return accordions.map((accordion) => {
+      return /* @__PURE__ */ jsx(
+        Accordion,
+        {
+          icon: accordion.icon,
+          label: getLabel(accordion.dictionaryId),
+          accordionProps: {
+            ...accordion.accordionProps
+          },
+          children: accordion.properties.map((property) => {
+            const value = property.getValue(data, endPointData);
+            return value ? /* @__PURE__ */ jsx(
+              PropertyValue,
+              {
+                property: getLabel(property.dictionaryId),
+                value
+              },
+              property.dictionaryId
+            ) : null;
+          })
+        },
+        accordion.dictionaryId
+      );
+    });
+  }, [accordions, data, endPointData, getLabel]);
+  return AccordionsComponents;
+}
+export {
+  useBaseAccordions as u
+};

package/hooks/useDynamicAccordions/useDynamicAccordions.d.ts

@@ -0,0 +1,6 @@
+import { ModuleDetailTabContent } from '../../components/ModuleDetailTabs';
+import { useDynamicAccordionsProps } from './types';
+/**
+ * Componente que muestra los datos generales de un inventario
+ */
+export declare function useDynamicAccordions(props: useDynamicAccordionsProps): (propsGeneral: ModuleDetailTabContent) => import("react/jsx-runtime").JSX.Element;

package/hooks/useDynamicAccordions/useDynamicAccordions.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { ScrollBar, Stack } from "@m4l/components";
+import { u as useBaseAccordions } from "./useBaseAccordions.js";
+function useDynamicAccordions(props) {
+  const { configDynamicAccordions } = props;
+  return function General(propsGeneral) {
+    const { data, endPointData } = propsGeneral;
+    const accordionsComponents = useBaseAccordions({
+      data,
+      endPointData,
+      configDynamicAccordions
+    });
+    return /* @__PURE__ */ jsx(ScrollBar, { children: /* @__PURE__ */ jsx(Stack, { direction: "column", gap: "4px", style: { height: "auto" }, children: accordionsComponents }) });
+  };
+}
+export {
+  useDynamicAccordions as u
+};

package/hooks/useMasterDetail/index.d.ts

@@ -1 +1 @@
-export declare const useMasterDetail: () => import('../../layouts/MasterDetailLayout/contexts/MasterDetailContext/types').MasterDetailContextProps;
+export declare const useMasterDetail: () => import('../..').MasterDetailContextProps;

package/hooks/useModule/index.d.ts

@@ -1,9 +1,5 @@
 /**
  * Hook para obtener el contexto de un módulo
- * @author Juan Escobar - automatic
- * @createdAt 2024-10-09 19:56:26 - automatic
- * @updatedAt 2024-10-09 20:00:30 - automatic
- * @updatedUser Juan Escobar - automatic
  */
 export declare const useModule: () => import('../../layouts/ModuleLayout/contexts/ModuleContext/types').ModuleLayoutContextProps;
 export default useModule;

package/index.d.ts

@@ -2,3 +2,4 @@ export * from './components';
 export * from './contexts';
 export * from './layouts';
 export * from './hooks';
+export * from './utils';

package/index.js

@@ -1,30 +1,35 @@
 import { M } from "./components/MFNoAuthApp/index.js";
-import { M as M2 } from "./components/MFHostApp/index.js";
+import { M as M2 } from "./components/MFHostApp/MFHostApp.js";
+import { M as M3 } from "./components/ModuleDetailTabs/ModuleDetailTabs.js";
 import { A, a } from "./contexts/AuthContext/index.js";
-import { M as M3 } from "./layouts/ModuleLayout/ModuleLayout.js";
-import { M as M4 } from "./layouts/MasterDetailLayout/MasterDetailLayout.js";
+import { M as M4 } from "./layouts/ModuleLayout/ModuleLayout.js";
 import { N } from "./layouts/NoAuthModuleLayout/index.js";
 import { d, g } from "./layouts/ModuleLayout/dicctionary.js";
-import { d as d2, g as g2 } from "./layouts/MasterDetailLayout/dicctionary.js";
-import { d as d3, g as g3 } from "./layouts/NoAuthModuleLayout/dicctionary.js";
+import { M as M5 } from "./layouts/MasterDetailLayout/MasterDetailLayout.js";
+import { g as g2 } from "./layouts/MasterDetailLayout/dicctionary.js";
+import { d as d2, g as g3 } from "./layouts/NoAuthModuleLayout/dicctionary.js";
 import { u } from "./hooks/useMasterDetail/index.js";
 import { u as u2 } from "./hooks/useAuth/index.js";
 import { u as u3 } from "./hooks/useModule/index.js";
+import { u as u4 } from "./hooks/useDynamicAccordions/useDynamicAccordions.js";
+import { c } from "./utils/createAppMF.js";
 export {
   A as AuthContext,
   a as AuthProvider,
   M2 as MFHostApp,
   M as MFNoAuthApp,
-  M4 as MasterDetailLayout,
-  M3 as ModuleLayout,
+  M5 as MasterDetailLayout,
+  M3 as ModuleDetailTabs,
+  M4 as ModuleLayout,
   N as NoAuthModuleLayout,
-  d2 as defaultMasterDetailDictionary,
+  c as createAppMF,
   d as defaultModuleLayoutDictionary,
-  d3 as defaultNoAuthModuleLayoutDictionary,
+  d2 as defaultNoAuthModuleLayoutDictionary,
   g2 as getMasterDetailLayoutComponentsDictionary,
   g as getModuleLayoutComponentsDictionary,
   g3 as getNoAuthModuleLayoutComponentsDictionary,
   u2 as useAuth,
+  u4 as useDynamicAccordions,
   u as useMasterDetail,
   u3 as useModule
 };

package/layouts/MasterDetailLayout/MasterDetailLayout.d.ts

@@ -1,9 +1,5 @@
 import { MasterDetailLayoutProps } from './types';
 /**
  * Layout de maestro detalle
- * @author Juan Escobar - automatic
- * @createdAt 2024-10-09 19:56:26 - automatic
- * @updatedAt 2024-12-05 10:48:46 - automatic
- * @updatedUser Bruce Escobar - automatic
  */
 export declare function MasterDetailLayout(props: MasterDetailLayoutProps): import("react/jsx-runtime").JSX.Element;