@weni/unnnic-system 3.11.1-alpha.2 → 3.11.2

package/src/components/InputDatePicker/__test__/InputDatePicker.spec.js

@@ -0,0 +1,159 @@
+import { mount } from '@vue/test-utils';
+import { beforeEach, describe, expect, it } from 'vitest';
+import InputDatePicker from '../InputDatePicker.vue';
+
+const factory = (props = {}) =>
+  mount(InputDatePicker, {
+    props: {
+      modelValue: {
+        start: null,
+        end: null,
+      },
+      ...props,
+    },
+    global: {
+      stubs: {
+        UnnnicInput: {
+          name: 'UnnnicInput',
+          template:
+            '<input data-testid="input" v-bind="$attrs" @focus="$emit(\'focus\', $event)" />',
+        },
+        UnnnicDatePicker: {
+          name: 'UnnnicDatePicker',
+          props: ['minDate', 'maxDate', 'periodBaseDate', 'options'],
+          template: '<div data-testid="datepicker"></div>',
+        },
+      },
+    },
+  });
+
+describe('InputDatePicker.vue', () => {
+  let wrapper;
+
+  beforeEach(() => {
+    wrapper = factory();
+  });
+
+  it('renders input and does not show datepicker by default', () => {
+    expect(wrapper.find('[data-testid="input"]').exists()).toBe(true);
+    expect(wrapper.find('[data-testid="datepicker"]').exists()).toBe(false);
+  });
+
+  it('opens datepicker when input receives focus', async () => {
+    const input = wrapper.find('[data-testid="input"]');
+    await input.trigger('focus');
+
+    wrapper.vm.showCalendarFilter = true;
+    await wrapper.vm.$nextTick();
+
+    expect(wrapper.findComponent({ name: 'UnnnicDatePicker' }).exists()).toBe(
+      true,
+    );
+  });
+
+  it('computes filterText placeholder when there is no date selected', () => {
+    expect(wrapper.vm.filterText).toBe('mm/dd/yyyy');
+  });
+
+  it('computes filterText from start and end dates', async () => {
+    const withDates = factory({
+      modelValue: {
+        start: '2025-01-10',
+        end: '2025-01-20',
+      },
+      format: 'YYYY-MM-DD',
+      inputFormat: 'MM-DD-YYYY',
+    });
+
+    expect(withDates.vm.filterText).toBe('01-10-2025 ~ 01-20-2025');
+  });
+
+  it('computes initialStartDate and initialEndDate for DatePicker', () => {
+    const withDates = factory({
+      modelValue: {
+        start: '2025-01-10',
+        end: '2025-01-20',
+      },
+    });
+
+    expect(withDates.vm.initialStartDate).toBe('01 10 2025');
+    expect(withDates.vm.initialEndDate).toBe('01 20 2025');
+  });
+
+  it('emits selectDate with formatted dates when DatePicker emits change', async () => {
+    wrapper.vm.showCalendarFilter = true;
+    await wrapper.vm.$nextTick();
+
+    const datePicker = wrapper.findComponent({ name: 'UnnnicDatePicker' });
+
+    const payload = {
+      startDate: '01-10-2025',
+      endDate: '01-20-2025',
+    };
+
+    await datePicker.vm.$emit('change', payload);
+
+    const emitted = wrapper.emitted('selectDate');
+    expect(emitted).toBeTruthy();
+
+    const [formatted] = emitted[0];
+    expect(formatted).toEqual({
+      start: '2025-01-10',
+      end: '2025-01-20',
+    });
+  });
+
+  it('emits update:model-value and closes dropdown when DatePicker emits submit', async () => {
+    wrapper.vm.showCalendarFilter = true;
+    await wrapper.vm.$nextTick();
+
+    const datePicker = wrapper.findComponent({ name: 'UnnnicDatePicker' });
+
+    const payload = {
+      startDate: '01-10-2025',
+      endDate: '01-20-2025',
+    };
+
+    await datePicker.vm.$emit('submit', payload);
+
+    const emitted = wrapper.emitted('update:model-value');
+    expect(emitted).toBeTruthy();
+
+    const [newValue] = emitted[0];
+    expect(newValue).toEqual({
+      start: '2025-01-10',
+      end: '2025-01-20',
+    });
+
+    expect(wrapper.vm.showCalendarFilter).toBe(false);
+  });
+
+  it('passes minDate, maxDate, options and periodBaseDate down to DatePicker', async () => {
+    const props = {
+      minDate: '2025-01-01',
+      maxDate: '2025-01-31',
+      periodBaseDate: '2025-01-15',
+      options: [{ name: 'Last 7 days', id: 'last-7-days' }],
+    };
+
+    wrapper = factory(props);
+    wrapper.vm.showCalendarFilter = true;
+    await wrapper.vm.$nextTick();
+
+    const datePicker = wrapper.findComponent({ name: 'UnnnicDatePicker' });
+    const dpProps = datePicker.props();
+
+    expect(dpProps.minDate).toBe(props.minDate);
+    expect(dpProps.maxDate).toBe(props.maxDate);
+    expect(dpProps.periodBaseDate).toBe(props.periodBaseDate);
+    expect(dpProps.options).toEqual(props.options);
+  });
+
+  it('closes dropdown on mouseout when clicking outside', () => {
+    wrapper.vm.showCalendarFilter = true;
+
+    wrapper.vm.mouseout({ target: document.createElement('div') });
+
+    expect(wrapper.vm.showCalendarFilter).toBe(false);
+  });
+});

package/src/components/ModalDialog/ModalDialog.vue

@@ -1,46 +1,64 @@
 <template>
-  <UnnnicDialog
-    :open="modelValue"
-    @update:open="$emit('update:modelValue', $event)"
+  <section
+    v-if="modelValue"
+    class="unnnic-modal-dialog"
+    data-testid="modal-dialog"
   >
-    <UnnnicDialogContent
-      :size="size === 'sm' ? 'small' : size === 'lg' ? 'large' : 'medium'"
-      :parentClass="['unnnic-modal-dialog', $attrs.class]"
-      class="unnnic-modal-dialog__container"
-      data-testid="modal-dialog"
-      @escape-key-down="persistentHandler"
-      @pointer-down-outside="persistentHandler"
+    <section
+      class="unnnic-modal-dialog__overlay"
+      data-testid="modal-overlay"
+      @click.stop="!persistent && close()"
+    />
+    <section
+      :class="[
+        'unnnic-modal-dialog__container',
+        `unnnic-modal-dialog__container--${size}`,
+      ]"
+      data-testid="modal-container"
     >
       <section
-        :class="[
-          'unnnic-modal-dialog__container__body',
-          {
-            'unnnic-modal-dialog__container__body--left-sidebar':
-              $slots.leftSidebar,
-          },
-        ]"
+        v-if="$slots.leftSidebar"
+        class="unnnic-modal-dialog__container__left-sidebar"
       >
-        <section
-          v-if="$slots.leftSidebar"
-          class="unnnic-modal-dialog__container__left-sidebar"
-        >
-          <slot name="leftSidebar" />
-        </section>
-        <UnnnicDialogHeader
+        <slot name="leftSidebar" />
+      </section>
+
+      <section class="unnnic-modal-dialog__container__body">
+        <header
           v-if="title"
-          :closeButton="showCloseIcon"
-          :type="type"
+          class="unnnic-modal-dialog__container__header"
         >
-          <UnnnicDialogTitle>
-            {{ title }}
-          </UnnnicDialogTitle>
-        </UnnnicDialogHeader>
+          <section class="unnnic-modal-dialog__container__title-container">
+            <UnnnicIcon
+              v-if="icon || type"
+              data-testid="title-icon"
+              class="unnnic-modal-dialog__container__title-icon"
+              :icon="icon || iconsMapper[type]?.icon"
+              :scheme="iconScheme || iconsMapper[type]?.scheme"
+              size="md"
+            />
+            <h1
+              class="unnnic-modal-dialog__container__title-text"
+              data-testid="title-text"
+            >
+              {{ title }}
+            </h1>
+          </section>
+          <UnnnicIcon
+            v-if="showCloseIcon"
+            data-testid="close-icon"
+            icon="close"
+            clickable
+            scheme="neutral-cloudy"
+            @click="close()"
+          />
+        </header>
         <section class="unnnic-modal-dialog__container__content">
           <slot></slot>
         </section>
-
-        <UnnnicDialogFooter
+        <section
           v-if="primaryButtonProps.text"
+          data-testid="actions-section"
           :class="[
             'unnnic-modal-dialog__container__actions',
             {
@@ -48,8 +66,6 @@
                 showActionsDivider,
             },
           ]"
-          :divider="showActionsDivider"
-          data-testid="actions-section"
         >
           <UnnnicButton
             v-if="!hideSecondaryButton"
@@ -76,30 +92,22 @@
             class="unnnic-modal-dialog__container__actions__primary-button"
             @click.stop="$emit('primaryButtonClick')"
           />
-        </UnnnicDialogFooter>
+        </section>
       </section>
-    </UnnnicDialogContent>
-  </UnnnicDialog>
+    </section>
+  </section>
 </template>
 
 <script>
+import UnnnicIcon from '../Icon.vue';
 import UnnnicButton from '../Button/Button.vue';
 import UnnnicI18n from '../../mixins/i18n';
-import UnnnicDialog from '../ui/dialog/Dialog.vue';
-import UnnnicDialogContent from '../ui/dialog/DialogContent.vue';
-import UnnnicDialogHeader from '../ui/dialog/DialogHeader.vue';
-import UnnnicDialogTitle from '../ui/dialog/DialogTitle.vue';
-import UnnnicDialogFooter from '../ui/dialog/DialogFooter.vue';
 
 export default {
   name: 'UnnnicModalDialog',
   components: {
+    UnnnicIcon,
     UnnnicButton,
-    UnnnicDialog,
-    UnnnicDialogContent,
-    UnnnicDialogHeader,
-    UnnnicDialogTitle,
-    UnnnicDialogFooter,
   },
   mixins: [UnnnicI18n],
   props: {
@@ -169,6 +177,11 @@ export default {
           es: 'Cancelar',
         },
       },
+      iconsMapper: {
+        success: { icon: 'check_circle', scheme: 'aux-green-500' },
+        warning: { icon: 'warning', scheme: 'aux-red-500' },
+        attention: { icon: 'error', scheme: 'aux-yellow-500' },
+      },
       primaryButtonTypeMapper: {
         success: 'primary',
         warning: 'warning',
@@ -188,39 +201,91 @@ export default {
     updateBodyOverflow(isHidden) {
       document.body.style.overflow = isHidden ? 'hidden' : '';
     },
-    persistentHandler(event) {
-      if (this.persistent) {
-        event.preventDefault();
-      }
-    },
   },
 };
 </script>
 
 <style lang="scss" scoped>
 @use '@/assets/scss/unnnic' as *;
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+.unnnic-modal-dialog {
+  width: 100vw;
+  height: 100vh;
+  position: fixed;
+  left: 0;
+  top: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 9999;
+
+  &__overlay {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.4);
+  }
+}
+
 .unnnic-modal-dialog__container {
+  display: flex;
+  background: $unnnic-color-neutral-white;
+  border-radius: $unnnic-spacing-xs;
+  box-shadow: $unnnic-shadow-level-near;
+  position: fixed;
+  max-height: calc(100vh - $unnnic-spacing-giant);
+  overflow: hidden;
+
+  &--sm {
+    width: 400px;
+  }
+  &--md {
+    width: 600px;
+  }
+  &--lg {
+    width: 800px;
+  }
+
   &__left-sidebar {
     background-color: $unnnic-color-neutral-black;
     color: $unnnic-color-neutral-white;
-
-    grid-area: left-sidebar;
-    grid-row: span 3;
   }
 
   &__body {
     flex: 1;
     display: flex;
     flex-direction: column;
+  }
 
-    overflow-y: auto;
+  &__header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    border-bottom: 1px solid $unnnic-color-neutral-soft;
+    padding: $unnnic-spacing-md;
+    flex-shrink: 0;
+  }
 
-    &--left-sidebar {
-      border-radius: $unnnic-radius-4 0 0 $unnnic-radius-4;
-      display: grid;
-      grid-template-columns: auto 1fr;
-      grid-template-areas: 'left-sidebar content';
-    }
+  &__title-container {
+    display: flex;
+    align-items: center;
+    gap: $unnnic-spacing-ant;
+  }
+
+  &__title-icon {
+    font-size: 28px;
+  }
+
+  &__title-text {
+    font-family: $unnnic-font-family-secondary;
+    font-size: $unnnic-font-size-title-sm;
+    font-weight: $unnnic-font-weight-black;
+    line-height: 28px;
+    color: $unnnic-color-neutral-darkest;
   }
 
   &__content {
@@ -244,5 +309,26 @@ export default {
       border-radius: $unnnic-border-radius-pill;
     }
   }
+
+  &__actions {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    grid-template-areas: 'secondary-button primary-button';
+    gap: $unnnic-spacing-sm;
+    padding: $unnnic-spacing-md;
+    flex-shrink: 0;
+
+    &--divider {
+      border-top: 1px solid $unnnic-color-neutral-soft;
+    }
+
+    &__secondary-button {
+      grid-area: secondary-button;
+    }
+
+    &__primary-button {
+      grid-area: primary-button;
+    }
+  }
 }
 </style>

package/src/components/ModalDialog/__tests__/ModalDialog.spec.js

@@ -1,5 +1,5 @@
 import { mount } from '@vue/test-utils';
-import { describe, it } from 'vitest';
+import { describe, it, vi } from 'vitest';
 import ModalDialog from '../ModalDialog.vue';
 
 describe('ModalDialog.vue', () => {
@@ -16,12 +16,7 @@ describe('ModalDialog.vue', () => {
         'onUpdate:modelValue': (e) => wrapper.setProps({ modelValue: e }),
       },
       global: {
-        stubs: [
-          'teleport',
-          'UnnnicIcon',
-          'UnnnicButton',
-          'UnnnicDialogContent',
-        ],
+        stubs: ['UnnnicIcon', 'UnnnicButton'],
       },
     });
   });
@@ -31,16 +26,231 @@ describe('ModalDialog.vue', () => {
       expect(wrapper.html()).toMatchSnapshot();
     });
 
+    it('should render correctly when modelValue is true', () => {
+      const modal = wrapper.find('[data-testid="modal-dialog"]');
+      expect(modal.exists()).toBe(true);
+    });
+
+    it('should not render when modelValue is false', async () => {
+      await wrapper.setProps({ modelValue: false });
+
+      const modal = wrapper.find('[data-testid="modal-dialog"]');
+      expect(modal.exists()).toBe(false);
+    });
+
     it('should apply the correct size class based on the size prop', async () => {
-      const modalContainer = wrapper.find('[data-testid="modal-dialog"]');
+      const modalContainer = wrapper.find('[data-testid="modal-container"]');
+      const defaultClass = 'unnnic-modal-dialog__container';
 
-      expect(modalContainer.attributes('size')).toContain('medium');
+      expect(modalContainer.classes()).toContain(defaultClass + '--md');
 
       await wrapper.setProps({ size: 'lg' });
-      expect(modalContainer.attributes('size')).toContain('large');
+      expect(modalContainer.classes()).toContain(defaultClass + '--lg');
 
       await wrapper.setProps({ size: 'sm' });
-      expect(modalContainer.attributes('size')).toContain('small');
+      expect(modalContainer.classes()).toContain(defaultClass + '--sm');
+    });
+
+    it('should render the icon and title when provided', () => {
+      const title = wrapper.find('[data-testid="title-text"]');
+      expect(title.exists()).toBe(true);
+      expect(title.text()).toBe('Test Title');
+
+      const icon = wrapper.findComponent('[data-testid="title-icon"]');
+      expect(icon.exists()).toBe(true);
+      expect(icon.props('icon')).toBe('test-icon');
+    });
+
+    it('should render the icon from iconsMapper when type prop is provided', async () => {
+      await wrapper.setProps({
+        type: 'success',
+        icon: '',
+      });
+
+      const icon = wrapper.findComponent('[data-testid="title-icon"]');
+      expect(icon.exists()).toBe(true);
+      expect(icon.props().icon).toBe(wrapper.vm.iconsMapper['success'].icon);
+    });
+
+    it('should not render the icon when both icon and type props are not provided', async () => {
+      await wrapper.setProps({
+        icon: '',
+        type: '',
+      });
+
+      const icon = wrapper.find('[data-testid="title-icon"]');
+      expect(icon.exists()).toBe(false);
+    });
+
+    it('should render the close icon when showCloseIcon is true', () => {
+      const closeIcon = wrapper.find('[data-testid="close-icon"]');
+      expect(closeIcon.exists()).toBe(true);
+    });
+
+    it('should not render buttons when primaryButtonProps is not provided', async () => {
+      await wrapper.setProps({ primaryButtonProps: undefined });
+
+      const primaryButton = wrapper.find('[data-testid="primary-button"]');
+      const secondaryButton = wrapper.find('[data-testid="secondary-button"]');
+      expect(primaryButton.exists()).toBe(false);
+      expect(secondaryButton.exists()).toBe(false);
+    });
+  });
+
+  describe('Overlay behavior', () => {
+    it('should close the modal when clicking on the overlay if persistent is false', async () => {
+      expect(wrapper.props().modelValue).toBe(true);
+
+      const overlay = wrapper.find('[data-testid="modal-overlay"]');
+      await overlay.trigger('click');
+
+      expect(wrapper.emitted('update:modelValue')).toBeTruthy();
+      expect(wrapper.emitted('update:modelValue')[0]).toEqual([false]);
+      expect(wrapper.props().modelValue).toBe(false);
+    });
+
+    it('should not close the modal when clicking on the overlay if persistent is true', async () => {
+      await wrapper.setProps({ persistent: true });
+
+      const overlay = wrapper.find('[data-testid="modal-overlay"]');
+      await overlay.trigger('click');
+
+      expect(wrapper.emitted('update:modelValue')).toBeFalsy();
+      expect(wrapper.props().modelValue).toBe(true);
+    });
+  });
+
+  describe('Slot rendering', () => {
+    it('should render leftSidebar slot when provided', () => {
+      const wrapper = mount(ModalDialog, {
+        props: {
+          modelValue: true,
+        },
+        slots: {
+          leftSidebar:
+            '<div data-testid="left-sidebar">Left Sidebar Content</div>',
+        },
+      });
+
+      const leftSidebar = wrapper.find('[data-testid="left-sidebar"]');
+      expect(leftSidebar.exists()).toBe(true);
+      expect(leftSidebar.text()).toBe('Left Sidebar Content');
+    });
+
+    it('should render default slot content', () => {
+      const wrapper = mount(ModalDialog, {
+        props: {
+          modelValue: true,
+        },
+        slots: {
+          default: '<div data-testid="default-slot">Default Slot Content</div>',
+        },
+      });
+
+      const defaultSlot = wrapper.find('[data-testid="default-slot"]');
+      expect(defaultSlot.exists()).toBe(true);
+      expect(defaultSlot.text()).toBe('Default Slot Content');
+    });
+  });
+
+  describe('Buttons actions', () => {
+    it('should close the modal when clicking on close icon', async () => {
+      const closeIcon = wrapper.find('[data-testid="close-icon"]');
+      await closeIcon.trigger('click');
+
+      expect(wrapper.emitted('update:modelValue')).toBeTruthy();
+      expect(wrapper.emitted('update:modelValue')[0]).toEqual([false]);
+      expect(wrapper.props().modelValue).toBe(false);
+    });
+
+    it('should emit primaryButtonClick event when the primary button is clicked', async () => {
+      const primaryButton = wrapper.find('[data-testid="primary-button"]');
+      await primaryButton.trigger('click');
+
+      expect(wrapper.emitted('primaryButtonClick')).toBeTruthy();
+    });
+
+    it('should emit secondaryButtonClick event when the secondary button is clicked', async () => {
+      await wrapper.setProps({
+        secondaryButtonProps: { text: 'Cancel' },
+      });
+
+      const secondaryButton = wrapper.find('[data-testid="secondary-button"]');
+      await secondaryButton.trigger('click');
+
+      expect(wrapper.emitted('secondaryButtonClick')).toBeTruthy();
+    });
+
+    it('should close the modal when the secondary button is clicked and no secondaryButtonClick event is provided', async () => {
+      const secondaryButton = wrapper.find('[data-testid="secondary-button"]');
+      await secondaryButton.trigger('click');
+
+      const emittedValue = wrapper.emitted('update:modelValue');
+
+      expect(emittedValue).toBeTruthy();
+      expect(emittedValue[0][0]).toEqual(false);
+    });
+  });
+
+  describe('Actions and appearance', () => {
+    it('should not render the secondary button when hideSecondaryButton is true', async () => {
+      await wrapper.setProps({
+        hideSecondaryButton: true,
+      });
+      const secondaryButton = wrapper.find('[data-testid="secondary-button"]');
+      expect(secondaryButton.exists()).toBe(false);
+    });
+
+    it('should apply a divider class to the actions section when showActionsDivider is true', async () => {
+      await wrapper.setProps({
+        showActionsDivider: true,
+      });
+
+      const actionsSection = wrapper.find('[data-testid="actions-section"]');
+      expect(actionsSection.classes()).toContain(
+        'unnnic-modal-dialog__container__actions--divider',
+      );
+    });
+  });
+
+  describe('Body overflow', () => {
+    it('should toggle body overflow based on modal visibility', async () => {
+      await wrapper.setProps({ modelValue: false });
+      const updateBodyOverflowSpy = vi.spyOn(wrapper.vm, 'updateBodyOverflow');
+
+      await wrapper.setProps({ modelValue: true });
+      expect(updateBodyOverflowSpy).toHaveBeenCalledWith(true);
+
+      await wrapper.setProps({ modelValue: false });
+      expect(updateBodyOverflowSpy).toHaveBeenCalledWith(false);
+    });
+  });
+
+  describe('Validators', () => {
+    describe('type prop validator', () => {
+      it('should validate type prop when a valid value is provided', () => {
+        const validTypes = ['success', 'warning', 'attention'];
+        validTypes.forEach((validType) => {
+          expect(ModalDialog.props.type.validate(validType)).toBe(true);
+        });
+      });
+
+      it('should invalidate type prop when an invalid value is provided', () => {
+        expect(ModalDialog.props.type.validate('invalidType')).toBe(false);
+      });
+    });
+
+    describe('size prop validator', () => {
+      it('should validate size prop when a valid value is provided', () => {
+        const validSizes = ['sm', 'md', 'lg'];
+        validSizes.forEach((validSize) => {
+          expect(ModalDialog.props.size.validate(validSize)).toBe(true);
+        });
+      });
+
+      it('should invalidate size prop when an invalid value is provided', () => {
+        expect(ModalDialog.props.size.validate('invalidSize')).toBe(false);
+      });
     });
   });
 });