@m4l/components 9.4.27 → 9.4.28-BE20260210-1

package/components/DynamicForm/subcomponents/DynamicFormCoupled/DynamicFormCoupled.js

@@ -0,0 +1,45 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { useFormContext, Controller } from "react-hook-form";
+import { D as DynamicFormCoupledInternal } from "../DynamicFormCoupledInternal/DynamicFormCoupledInternal.js";
+const DynamicFormCoupled = forwardRef((props) => {
+  const {
+    name,
+    value,
+    initialValues,
+    validationSchema,
+    ownerState,
+    currentSize,
+    fieldWrapperClassName,
+    dataTestId,
+    className
+  } = props;
+  const { control } = useFormContext();
+  return /* @__PURE__ */ jsx(
+    Controller,
+    {
+      name,
+      control,
+      render: ({ field: { onChange } }) => {
+        return /* @__PURE__ */ jsx(
+          DynamicFormCoupledInternal,
+          {
+            value,
+            initialValues,
+            validationSchema,
+            ownerState,
+            currentSize,
+            fieldWrapperClassName,
+            dataTestId,
+            className,
+            onChange
+          }
+        );
+      }
+    }
+  );
+});
+DynamicFormCoupled.displayName = "DynamicFormCoupled";
+export {
+  DynamicFormCoupled as D
+};

package/components/DynamicForm/subcomponents/DynamicFormCoupledInternal/DynamicFormCoupledInternal.d.ts

@@ -0,0 +1,7 @@
+import { DynamicFormCoupledInternalProps } from '../../types';
+/**
+ * Formulario acoplado que se monta dentro de un Controller externo.
+ * Crea su propio estado de formulario y delega el render en el contenido interno.
+ * Se usa cuando coupled=true para exponer el formulario como un campo dentro de un formulario padre.
+ */
+export declare const DynamicFormCoupledInternal: import('react').ForwardRefExoticComponent<DynamicFormCoupledInternalProps & import('react').RefAttributes<HTMLDivElement>>;

package/components/DynamicForm/subcomponents/DynamicFormCoupledInternal/DynamicFormCoupledInternal.js

@@ -0,0 +1,86 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef, useRef, useEffect } from "react";
+import { useForm, FormProvider } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { D as DynamicFormCoupledInternalContent } from "../DynamicFormCoupledInternalContent/DynamicFormCoupledInternalContent.js";
+const DynamicFormCoupledInternal = forwardRef((props) => {
+  const {
+    value,
+    initialValues,
+    validationSchema,
+    ownerState,
+    currentSize,
+    fieldWrapperClassName,
+    dataTestId,
+    className,
+    onChange
+  } = props;
+  const internalFormMethods = useForm({
+    resolver: yupResolver(validationSchema),
+    defaultValues: initialValues,
+    mode: "onTouched"
+  });
+  const lastSentValueRef = useRef(null);
+  useEffect(() => {
+    const keys = Object.keys(initialValues);
+    keys.forEach((key) => {
+      const fieldName = key;
+      const fieldValue = initialValues[key];
+      internalFormMethods.setValue(fieldName, fieldValue, {
+        /**
+         * Opciones de setValue para sincronización silenciosa:
+         *
+         * **shouldValidate: false**
+         * - Evita ejecutar las validaciones de Yup cuando se establecen los valores iniciales.
+         * - Razón: Los valores iniciales ya vienen validados del backend, no necesitan validarse
+         *   nuevamente al sincronizarse. Además, validar todos los campos al cargar puede ser
+         *   costoso en formularios grandes y mostrar errores antes de que el usuario interactúe.
+         * - Sin esto: Se ejecutarían todas las validaciones al cargar, mostrando posibles errores
+         *   de campos que el usuario aún no ha tocado.
+         *
+         * **shouldDirty: false**
+         * - Evita marcar los campos como "sucios" (modificados) cuando se sincronizan valores iniciales.
+         * - Razón: Los valores iniciales no son modificaciones del usuario, son el estado base.
+         *   Marcar campos como "dirty" haría que el formulario parezca modificado cuando en realidad
+         *   solo se están cargando los datos iniciales.
+         * - Sin esto: El formulario se marcaría como "modificado" inmediatamente al cargar,
+         *   lo que podría activar advertencias de "tienes cambios sin guardar" incorrectamente.
+         *
+         * **shouldTouch: false**
+         * - Evita marcar los campos como "tocados" (visitados) cuando se establecen valores iniciales.
+         * - Razón: Un campo "touched" normalmente significa que el usuario lo ha visitado/interactuado.
+         *   Los valores iniciales no representan interacción del usuario, solo datos precargados.
+         * - Sin esto: Los campos se marcarían como "touched" al cargar, lo que podría mostrar
+         *   mensajes de error o estilos de validación antes de que el usuario interactúe con ellos.
+         *
+         * **Resumen:**
+         * Estas opciones garantizan que la sincronización de valores iniciales sea "silenciosa",
+         * actualizando solo los valores sin afectar el estado de validación, modificación o
+         * interacción del formulario. El usuario solo verá validaciones y estados cuando
+         * realmente interactúe con los campos.
+         */
+        shouldValidate: false,
+        shouldDirty: false,
+        shouldTouch: false
+      });
+    });
+  }, [initialValues, internalFormMethods]);
+  return /* @__PURE__ */ jsx(FormProvider, { ...internalFormMethods, children: /* @__PURE__ */ jsx(
+    DynamicFormCoupledInternalContent,
+    {
+      value,
+      ownerState,
+      currentSize,
+      fieldWrapperClassName,
+      dataTestId,
+      className,
+      onChange,
+      lastSentValueRef,
+      internalFormMethods
+    }
+  ) });
+});
+DynamicFormCoupledInternal.displayName = "DynamicFormCoupledInternal";
+export {
+  DynamicFormCoupledInternal as D
+};

package/components/DynamicForm/subcomponents/DynamicFormCoupledInternalContent/DynamicFormCoupledInternalContent.d.ts

@@ -0,0 +1,9 @@
+import { DynamicFormCoupledInternalContentProps } from '../../types';
+/**
+ * Componente que se encarga de renderizar el contenido del formulario acoplado.
+ * Valida y notifica cambios solo en campos visibles al formulario padre.
+ */
+export declare const DynamicFormCoupledInternalContent: {
+    (props: DynamicFormCoupledInternalContentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/components/DynamicForm/subcomponents/DynamicFormCoupledInternalContent/DynamicFormCoupledInternalContent.js

@@ -0,0 +1,62 @@
+import { jsx } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { u as useDynamicFormConditionals } from "../../hooks/useDynamicFormConditionals/useDynamicFormConditionals.js";
+import { D as DynamicFormContent } from "../DynamicFormContent/DynamicFormContent.js";
+const DynamicFormCoupledInternalContent = (props) => {
+  const {
+    value,
+    ownerState,
+    currentSize,
+    fieldWrapperClassName,
+    dataTestId,
+    onChange,
+    lastSentValueRef,
+    internalFormMethods
+  } = props;
+  const { visibleFields } = useDynamicFormConditionals(value);
+  useEffect(() => {
+    const notifyChange = () => {
+      const visibleFieldNames = visibleFields.map((field) => field.name);
+      internalFormMethods.trigger(visibleFieldNames).then(() => {
+        const errors = internalFormMethods.formState.errors;
+        const visibleFieldsValid = visibleFieldNames.every((fieldName) => {
+          return !errors[fieldName];
+        });
+        const currentValues = internalFormMethods.getValues();
+        const visibleFieldValues = {};
+        visibleFieldNames.forEach((fieldName) => {
+          if (currentValues[fieldName] !== void 0) {
+            visibleFieldValues[fieldName] = currentValues[fieldName];
+          }
+        });
+        const formFieldsValue = {
+          ...visibleFieldValues,
+          isDynamicFormValidInternal: visibleFieldsValid
+        };
+        const serializedValue = JSON.stringify(formFieldsValue);
+        if (serializedValue !== lastSentValueRef.current) {
+          lastSentValueRef.current = serializedValue;
+          onChange(formFieldsValue);
+        }
+      });
+    };
+    const subscription = internalFormMethods.watch(notifyChange);
+    notifyChange();
+    return () => subscription.unsubscribe();
+  }, [internalFormMethods, visibleFields, onChange, lastSentValueRef]);
+  return /* @__PURE__ */ jsx(
+    DynamicFormContent,
+    {
+      data: value,
+      ownerState,
+      currentSize,
+      fieldWrapperClassName,
+      dataTestId,
+      coupled: true
+    }
+  );
+};
+DynamicFormCoupledInternalContent.displayName = "DynamicFormCoupledInternalContent";
+export {
+  DynamicFormCoupledInternalContent as D
+};

package/components/DynamicForm/subcomponents/index.d.ts

@@ -0,0 +1,4 @@
+export { DynamicFormCoupled } from './DynamicFormCoupled/DynamicFormCoupled';
+export { DynamicFormCoupledInternal } from './DynamicFormCoupledInternal/DynamicFormCoupledInternal';
+export { DynamicFormCoupledInternalContent } from './DynamicFormCoupledInternalContent/DynamicFormCoupledInternalContent';
+export { DynamicFormContent } from './DynamicFormContent/DynamicFormContent';

package/components/DynamicForm/subcomponents/index.js

@@ -0,0 +1 @@
+

package/components/DynamicForm/types.d.ts

@@ -0,0 +1,313 @@
+import { Theme } from '@mui/material/styles';
+import { MutableRefObject, ReactNode } from 'react';
+import { Sizes } from '@m4l/styles';
+import { DynamicFormSlots } from './slots';
+import { DYNAMIC_FORM_KEY_COMPONENT } from './constants';
+import { M4LOverridesStyleRules } from '../../@types/augmentations';
+import { RHFormValues, RHFormProviderRef } from '../hook-form/RHFormProvider/types';
+import { ActionsFormIntroProps } from '../CommonActions/components/ActionFormIntro/types';
+import { useForm } from 'react-hook-form';
+/**
+ * Tipos del contrato API - FormMetadata
+ */
+export interface FormMetadata {
+    id: number;
+    name: string;
+    version: number;
+    nameDictionaryId: number;
+    descriptionDictionaryId: number;
+}
+/**
+ * Tipos del contrato API - FieldType
+ */
+export interface FieldType {
+    id: string;
+    name: string;
+    rhfComponent: string;
+    rhfComponentProps?: Record<string, unknown>;
+    supportsOptions: boolean;
+    nameDictionaryId: number;
+    supportsValidation: boolean;
+}
+/**
+ * Tipos del contrato API - ValidationType
+ */
+export interface ValidationType {
+    id: string;
+    name: string;
+    requiresValue: boolean;
+    nameDictionaryId: number;
+}
+/**
+ * Tipos del contrato API - Validation
+ */
+export interface FieldValidation {
+    id: string;
+    isActive: boolean;
+    displayOrder: number;
+    errorMessage: string;
+    validationType?: ValidationType;
+    type?: ValidationType;
+    value?: string;
+}
+/**
+ * Tipos del contrato API - FieldOption
+ */
+export interface FieldOption {
+    id: number;
+    name: string | null;
+    value: string;
+    isDefault: boolean;
+    displayOrder: number;
+    nameDictionaryId: number;
+}
+/**
+ * Tipos del contrato API - FieldValue
+ */
+export interface FieldValue {
+    id: number;
+    name: string | null;
+    value: string;
+    isVisible: boolean;
+    valueDouble: number | null;
+    valueString: string | null;
+    valueBoolean: boolean | null;
+    valueInteger: number | null;
+    valueTimestamp: string | null;
+    visibilityReason: string;
+}
+/**
+ * Tipos del contrato API - Field
+ */
+export interface Field {
+    id: number;
+    name: string;
+    options: FieldOption[];
+    fieldType: FieldType;
+    helperText: string | null;
+    isRequired: boolean;
+    placeholder: string | null;
+    propertyId: string;
+    validations: FieldValidation[];
+    currentValue: FieldValue | null;
+    defaultValue: string | null;
+    displayOrder: number;
+    isConditional: boolean;
+    validationErrors: unknown[];
+    nameDictionaryId: number;
+    descriptionDictionaryId: number;
+}
+/**
+ * Tipos del contrato API - ConditionalRuleOperator
+ */
+export interface ConditionalRuleOperator {
+    id: string;
+    name: string;
+    nameDictionaryId: number;
+}
+/**
+ * Tipos del contrato API - ConditionalRule
+ */
+export interface ConditionalRule {
+    id: string;
+    operator: ConditionalRuleOperator;
+    isActive: boolean;
+    actionType: 'show' | 'hide';
+    displayOrder: number;
+    conditionValue: string;
+    sourceFieldId: number;
+    targetFieldId: number;
+    sourceFieldName: string;
+    targetFieldName: string;
+}
+/**
+ * Tipos del contrato API - FormInstance
+ */
+export interface FormInstance {
+    id: number;
+    name: string | null;
+    createdAt: string;
+    updatedAt: string;
+    resourceTypeId: string;
+    resourceSerialId: string;
+}
+/**
+ * Tipos del contrato API - DynamicFormApiResponse
+ */
+export interface DynamicFormApiResponse {
+    form: FormMetadata;
+    fields: Field[];
+    instance: FormInstance;
+    conditionalRules: ConditionalRule[];
+}
+/**
+ * Propiedades del componente DynamicForm.
+ */
+export interface DynamicFormProps {
+    /**
+     * ID del formulario.
+     */
+    idForm?: number;
+    /**
+     * ID de la instancia del formulario.
+     */
+    idFormInstance?: number;
+    /**
+     * Endpoint de entrada.
+     */
+    inputEndpoint?: string;
+    /**
+     * Endpoint de salida.
+     */
+    outputEndpoint?: string;
+    /**
+     * Datos iniciales del formulario. Si se proporciona, se usarán en lugar de obtenerlos del endpoint.
+     */
+    data?: DynamicFormApiResponse | null;
+    /**
+     * Función que se ejecuta para formatear los datos de entrada.
+     */
+    formatInputData?: (data: Record<string, unknown>) => Record<string, unknown>;
+    /**
+     * Función que se ejecuta para formatear los datos de salida.
+     */
+    formatOutputData?: (data: Record<string, unknown>) => Record<string, unknown>;
+    /**
+     * Función que se ejecuta al enviar el formulario con los datos validados.
+     */
+    onSubmit: (data: Record<string, unknown>) => void | Promise<void>;
+    /**
+     * Función que se ejecuta cuando hay un error en la validación del formulario.
+     */
+    onSubmitError?: (errors: Record<string, unknown>) => void;
+    /**
+     * Tamaño del componente.
+     */
+    size?: Extract<Sizes, 'small' | 'medium'>;
+    /**
+     * Clase CSS adicional.
+     */
+    className?: string;
+    /**
+     * ID para testing.
+     */
+    dataTestId?: string;
+    /**
+     * Clase CSS adicional para el wrapper de cada campo.
+     */
+    fieldWrapperClassName?: string;
+    /**
+     * Si el formulario está acoplado (coupled=true), se expone como un campo de React Hook Form mediante Controller.
+     * Si está desacoplado (coupled=false), maneja el submit internamente con RHFormProvider.
+     * Por defecto es false (modo desacoplado con RHFormProvider interno).
+     */
+    coupled?: boolean;
+    /**
+     * Nombre del campo cuando el formulario está acoplado (coupled=true).
+     * Se usa para suscribir el DynamicForm a React Hook Form a través del Controller.
+     * Requerido cuando coupled es true.
+     */
+    name?: string;
+    /**
+     * Props para personalizar el ActionFormIntro.
+     * Solo se usa cuando coupled es false (modo desacoplado).
+     * Si no se proporciona, se usan los valores por defecto.
+     */
+    actionFormIntroProps?: Partial<ActionsFormIntroProps>;
+    /**
+     * Renderizado personalizado para las acciones del formulario.
+     * Solo se usa cuando coupled es false (modo desacoplado).
+     * Si se proporciona, reemplaza el ActionsContainer y ActionFormIntro por defecto.
+     */
+    renderActions?: () => ReactNode;
+}
+/**
+ * Owner state del componente usado para definir propiedades internas de estilo y comportamiento.
+ */
+export interface DynamicFormOwnerState extends Pick<DynamicFormProps, 'size'> {
+    [key: string]: unknown;
+}
+/**
+ * Define los tipos de Slots disponibles para el componente.
+ */
+export type DynamicFormSlotsType = keyof typeof DynamicFormSlots;
+/**
+ * Estilos aplicables al componente usando temas y slots personalizados.
+ */
+export type DynamicFormStyles = M4LOverridesStyleRules<DynamicFormSlotsType, typeof DYNAMIC_FORM_KEY_COMPONENT, Theme>;
+/**
+ * Tipo para los valores del formulario dinámico.
+ */
+export type DynamicFormValues = RHFormValues & Record<string, unknown>;
+/**
+ * Tipo para el valor que se expone cuando el DynamicForm está acoplado (coupled=true).
+ * Contiene los valores de los campos y el estado de validación interno.
+ */
+export interface DynamicFormFieldsValue {
+    [fieldName: string]: unknown;
+    isDynamicFormValidInternal: boolean;
+}
+/**
+ * Tipo que define los métodos expuestos a través de la ref del DynamicForm.
+ * Expone la API de RHFormProvider para acceso desde el componente padre.
+ */
+export type DynamicFormRef = RHFormProviderRef<DynamicFormValues>;
+/**
+ * Props del componente DynamicFormCoupled.
+ * Se usa cuando coupled=true y el formulario debe exponerse como un campo de React Hook Form mediante Controller.
+ */
+export interface DynamicFormCoupledProps {
+    name: string;
+    value: DynamicFormApiResponse;
+    initialValues: DynamicFormValues;
+    validationSchema: any;
+    ownerState: DynamicFormOwnerState;
+    currentSize: 'small' | 'medium';
+    fieldWrapperClassName?: string;
+    dataTestId?: string;
+    className?: string;
+}
+/**
+ * Props del componente interno que maneja el formulario acoplado.
+ * El formulario interno funciona independientemente y expone sus valores a través del Controller.
+ */
+export interface DynamicFormCoupledInternalProps {
+    value: DynamicFormApiResponse;
+    initialValues: DynamicFormValues;
+    validationSchema: any;
+    ownerState: DynamicFormOwnerState;
+    currentSize: 'small' | 'medium';
+    fieldWrapperClassName?: string;
+    dataTestId?: string;
+    className?: string;
+    onChange: (value: DynamicFormFieldsValue) => void;
+}
+/**
+ * Props del componente interno que valida y notifica cambios solo en campos visibles.
+ * Se usa cuando coupled=true.
+ */
+export interface DynamicFormCoupledInternalContentProps {
+    value: DynamicFormApiResponse;
+    ownerState: DynamicFormOwnerState;
+    currentSize: 'small' | 'medium';
+    fieldWrapperClassName?: string;
+    dataTestId?: string;
+    className?: string;
+    onChange: (value: DynamicFormFieldsValue) => void;
+    lastSentValueRef: MutableRefObject<string | null>;
+    internalFormMethods: ReturnType<typeof useForm<DynamicFormValues>>;
+}
+/**
+ * Props del componente interno que renderiza los campos del formulario.
+ * Debe estar dentro del contexto de RHFormProvider para acceder a useFormContext.
+ */
+export interface DynamicFormContentProps {
+    data: DynamicFormApiResponse;
+    ownerState: DynamicFormOwnerState;
+    currentSize: 'small' | 'medium';
+    fieldWrapperClassName?: string;
+    dataTestId?: string;
+    coupled?: boolean;
+    actionFormIntroProps?: Partial<DynamicFormProps['actionFormIntroProps']>;
+    renderActions?: DynamicFormProps['renderActions'];
+}

package/components/extended/mui/Autocomplete/Autocomplete.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/constants.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/dictionary.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/hooks/useAutocomplete/useAutocomplete.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/hooks/useEndAdornments.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/hooks/useMultipleChips.js

@@ -15,7 +15,7 @@ function useMultipleChips(props) {
     getOptionStartAdornment,
     getOptionEndAdornment
   } = props;
-  const startAdornmentClone = useMemo(() => {
+  const externalStartAdornment = useMemo(() => {
     if (!startAdornment) {
       return null;
     }
@@ -53,7 +53,7 @@ function useMultipleChips(props) {
     getOptionEndAdornment,
     adjustedSize
   ]);
-  const memoizedStartAdornment = useMemo(() => {
+  const selectedOptionStartAdornment = useMemo(() => {
     if (multiple || !selectedValue || Array.isArray(selectedValue) && selectedValue.length === 0) {
       return null;
     }
@@ -69,7 +69,7 @@ function useMultipleChips(props) {
     getOptionStartAdornment,
     adjustedSize
   ]);
-  const internalAdornments = useMemo(() => {
+  const multipleSelectionChips = useMemo(() => {
     if (!(Array.isArray(selectedValue) && multiple && selectedValue.length > 0)) {
       return null;
     }
@@ -100,18 +100,21 @@ function useMultipleChips(props) {
     ownerState,
     memoizedIcons
   ]);
-  if (startAdornmentClone && internalAdornments) {
+  if (externalStartAdornment && multipleSelectionChips) {
     return /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx(WrapperStartAdornmentStyled, { role: "img", "aria-hidden": "true", ownerState, children: startAdornmentClone }),
-      internalAdornments
+      /* @__PURE__ */ jsx(WrapperStartAdornmentStyled, { role: "img", "aria-hidden": "true", ownerState, children: externalStartAdornment }),
+      multipleSelectionChips
     ] });
   }
-  if (startAdornmentClone) {
+  if (externalStartAdornment) {
     return /* @__PURE__ */ jsxs(WrapperStartAdornmentStyled, { role: "img", "aria-hidden": "true", ownerState, children: [
-      startAdornmentClone,
-      !multiple && memoizedStartAdornment
+      externalStartAdornment,
+      !multiple && selectedOptionStartAdornment
     ] });
   }
+  if (!multiple && selectedOptionStartAdornment && !externalStartAdornment) {
+    return /* @__PURE__ */ jsx(WrapperStartAdornmentStyled, { role: "img", "aria-hidden": "true", ownerState, children: selectedOptionStartAdornment });
+  }
   if (!getOptionLabelLocal) {
     console.error("useStartAdornments: getOptionLabelLocal is required");
     return null;
@@ -120,7 +123,7 @@ function useMultipleChips(props) {
     console.error("useStartAdornments: handleDelete is required");
     return null;
   }
-  return internalAdornments;
+  return multipleSelectionChips;
 }
 export {
   useMultipleChips as u

package/components/extended/mui/Autocomplete/hooks/useMultipleChips.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/hooks/useValuesAndHandlers.js

@@ -126,11 +126,6 @@ function useValuesAndHandlers(props) {
       }
     }
   }, [readOnly, value, getOptionLabelLocal, multiple, inputValue]);
-  useEffect(() => {
-    if (open === false && value === null && inputValue !== "") {
-      setInputValue("");
-    }
-  }, [value, open, inputValue]);
   const checkKeyDown = (e) => {
     if (e.code === "Enter") {
       e.preventDefault();

package/components/extended/mui/Autocomplete/hooks/useValuesAndHandlers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/icons.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/subcomponents/LoadingText/LoadingText.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/subcomponents/NoOptionsText/NoOptionsText.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/subcomponents/PopperComponent/PopperComponent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/subcomponents/RenderAdornment/RenderAdornment.js

@@ -24,7 +24,8 @@ const renderAdornment = (propsResource, adjustedSize) => {
         {
           src: resource,
           width: 14,
-          height: 14
+          height: 14,
+          enableIntersectionObserver: false
         }
       );
     } else {

package/components/extended/mui/Autocomplete/subcomponents/RenderAdornment/RenderAdornment.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/extended/mui/Autocomplete/subcomponents/renderOptions/renderOptions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/hook-form/RHFCheckbox/index.js

@@ -0,0 +1 @@
+

package/components/hook-form/RHFCheckbox/types.js

@@ -0,0 +1 @@
+