@weni/unnnic-system 3.12.7 → 3.12.8-alpha-teleports.0

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

@@ -3,102 +3,380 @@ import { mount } from '@vue/test-utils';
 
 import ToolTip from '../ToolTip.vue';
 
-const createWrapper = (props) => {
-  return mount(ToolTip, { props });
+globalThis.ResizeObserver = vi.fn().mockImplementation(() => ({
+  observe: vi.fn(),
+  unobserve: vi.fn(),
+  disconnect: vi.fn(),
+}));
+
+const createWrapper = (props = {}, slots = {}) => {
+  return mount(ToolTip, {
+    props,
+    slots: {
+      default: '<button data-testid="trigger-button">Hover me</button>',
+      ...slots,
+    },
+    attachTo: document.body,
+    global: {
+      stubs: {
+        teleport: true,
+      },
+    },
+  });
 };
 
 describe('ToolTip', () => {
   let wrapper;
+
   beforeEach(() => {
-    wrapper = createWrapper({ text: 'Text', enabled: true });
+    wrapper = createWrapper({ text: 'Tooltip text', enabled: true });
   });
 
-  it('should not display the tooltip when enabled is false', async () => {
-    await wrapper.setProps({ enabled: false });
-    const tooltipLabel = wrapper.find('[data-testid="tooltip-label"]');
-    expect(tooltipLabel.isVisible()).toBe(false);
+  afterEach(() => {
+    if (wrapper) {
+      wrapper.unmount();
+    }
   });
 
-  it('should display the tooltip when enabled is true', async () => {
-    const tooltipLabel = wrapper.find('[data-testid="tooltip-label"]');
-    expect(tooltipLabel.isVisible()).toBe(true);
+  describe('Component Rendering', () => {
+    it('should render the component', () => {
+      expect(wrapper.exists()).toBe(true);
+      expect(wrapper.vm).toBeTruthy();
+    });
+
+    it('should render slot content', () => {
+      const triggerButton = wrapper.find('[data-testid="trigger-button"]');
+      expect(triggerButton.exists()).toBe(true);
+      expect(triggerButton.text()).toBe('Hover me');
+    });
+
+    it('should render custom slot content', () => {
+      const customWrapper = createWrapper(
+        { text: 'Tooltip text', enabled: true },
+        {
+          default: '<span data-testid="custom-trigger">Custom Content</span>',
+        },
+      );
+
+      const customTrigger = customWrapper.find(
+        '[data-testid="custom-trigger"]',
+      );
+      expect(customTrigger.exists()).toBe(true);
+      expect(customTrigger.text()).toBe('Custom Content');
+
+      customWrapper.unmount();
+    });
   });
 
-  it('should force open the tooltip when forceOpen is true', async () => {
-    await wrapper.setProps({ enabled: false, forceOpen: true });
+  describe('Props', () => {
+    it('should accept text prop', () => {
+      expect(wrapper.vm.$props.text).toBe('Tooltip text');
+    });
+
+    it('should accept enabled prop', () => {
+      expect(wrapper.vm.$props.enabled).toBe(true);
+    });
+
+    it('should accept forceOpen prop', () => {
+      const testWrapper = createWrapper({ text: 'Text', forceOpen: true });
+      expect(testWrapper.vm.$props.forceOpen).toBe(true);
+      testWrapper.unmount();
+    });
+
+    it('should accept side prop with valid values', () => {
+      const sides = ['top', 'right', 'bottom', 'left'];
+
+      sides.forEach((side) => {
+        const sideWrapper = createWrapper({
+          text: 'Text',
+          enabled: true,
+          side,
+        });
+        expect(sideWrapper.vm.$props.side).toBe(side);
+        sideWrapper.unmount();
+      });
+    });
+
+    it('should default to "right" side when not specified', () => {
+      expect(wrapper.vm.$props.side).toBe('right');
+    });
+
+    it('should accept maxWidth prop', () => {
+      const maxWidthWrapper = createWrapper({
+        text: 'Text',
+        enabled: true,
+        maxWidth: '200px',
+      });
+
+      expect(maxWidthWrapper.vm.$props.maxWidth).toBe('200px');
 
-    const tooltipLabel = wrapper.find('[data-testid="tooltip-label"]');
-    expect(tooltipLabel.isVisible()).toBe(true);
+      maxWidthWrapper.unmount();
+    });
+
+    it('should accept enableHtml prop', () => {
+      const htmlWrapper = createWrapper({
+        text: 'Text',
+        enableHtml: true,
+      });
+
+      expect(htmlWrapper.vm.$props.enableHtml).toBe(true);
+
+      htmlWrapper.unmount();
+    });
   });
 
-  it('should position the tooltip correctly based on the side prop', async () => {
-    const sideValues = ['top', 'right', 'bottom', 'left'];
+  describe('Boolean Props', () => {
+    it('should handle enabled false', () => {
+      const disabledWrapper = createWrapper({
+        text: 'Text',
+        enabled: false,
+      });
 
-    for (let side of sideValues) {
-      await wrapper.setProps({ side });
-      const tooltipLabel = wrapper.find('[data-testid="tooltip-label"]');
-      expect(tooltipLabel.classes()).include(`unnnic-tooltip-label-${side}`);
-    }
+      expect(disabledWrapper.vm.$props.enabled).toBe(false);
+
+      disabledWrapper.unmount();
+    });
+
+    it('should handle forceOpen true', () => {
+      const forceOpenWrapper = createWrapper({
+        text: 'Text',
+        enabled: false,
+        forceOpen: true,
+      });
+
+      expect(forceOpenWrapper.vm.$props.forceOpen).toBe(true);
+
+      forceOpenWrapper.unmount();
+    });
+
+    it('should handle enableHtml false', () => {
+      expect(wrapper.vm.$props.enableHtml).toBe(false);
+    });
   });
 
-  it('should split tooltip text into multiple lines', async () => {
-    await wrapper.setProps({ text: 'First line\nSecond line' });
+  describe('Text Content Rendering', () => {
+    it('should accept plain text content via prop', () => {
+      const plainWrapper = createWrapper({
+        text: 'Simple tooltip text',
+        enabled: true,
+      });
+
+      expect(plainWrapper.vm.$props.text).toBe('Simple tooltip text');
+
+      plainWrapper.unmount();
+    });
 
-    const tooltipLabel = wrapper.find('[data-testid="tooltip-label"]');
+    it('should accept multiline text via prop', () => {
+      const multilineWrapper = createWrapper({
+        text: 'First line\nSecond line\nThird line',
+        enabled: true,
+      });
 
-    expect(tooltipLabel.text()).toContain('First line');
-    expect(tooltipLabel.text()).toContain('Second line');
+      expect(multilineWrapper.vm.$props.text).toBe(
+        'First line\nSecond line\nThird line',
+      );
 
-    const brElements = tooltipLabel.findAll('br');
-    expect(brElements.length).toBe(2);
+      multilineWrapper.unmount();
+    });
+
+    it('should handle empty text', () => {
+      const emptyWrapper = createWrapper({ text: '', enabled: true });
+
+      expect(emptyWrapper.vm.$props.text).toBe('');
+      expect(emptyWrapper.exists()).toBe(true);
+
+      emptyWrapper.unmount();
+    });
   });
 
-  it('should display shortcutText when provided', async () => {
-    await wrapper.setProps({ shortcutText: 'Ctrl+C' });
+  describe('HTML Content', () => {
+    it('should accept HTML text with enableHtml prop set to true', () => {
+      const htmlWrapper = createWrapper({
+        enableHtml: true,
+        enabled: true,
+        text: 'Tooltip with <strong>bold</strong> text',
+      });
 
-    const tooltipShortcut = wrapper.find(
-      '[data-testid="tooltip-label-shortcut"]',
-    );
-    expect(tooltipShortcut.exists()).toBe(true);
-    expect(tooltipShortcut.text()).toBe('Ctrl+C');
+      expect(htmlWrapper.vm.$props.enableHtml).toBe(true);
+      expect(htmlWrapper.vm.$props.text).toBe(
+        'Tooltip with <strong>bold</strong> text',
+      );
+
+      htmlWrapper.unmount();
+    });
+
+    it('should accept HTML link with enableHtml prop', () => {
+      const linkWrapper = createWrapper({
+        enableHtml: true,
+        enabled: true,
+        text: 'Visit <a href="https://weni.ai/" target="_blank">Weni</a>',
+      });
+
+      expect(linkWrapper.vm.$props.enableHtml).toBe(true);
+      expect(linkWrapper.vm.$props.text).toContain('href="https://weni.ai/"');
+      expect(linkWrapper.vm.$props.text).toContain('target="_blank"');
+
+      linkWrapper.unmount();
+    });
+
+    it('should handle plain text when enableHtml is false', () => {
+      const plainWrapper = createWrapper({
+        enableHtml: false,
+        enabled: true,
+        text: 'Tooltip with <strong>bold</strong> text',
+      });
+
+      expect(plainWrapper.vm.$props.enableHtml).toBe(false);
+      expect(plainWrapper.vm.$props.text).toBe(
+        'Tooltip with <strong>bold</strong> text',
+      );
+
+      plainWrapper.unmount();
+    });
+  });
+
+  describe('Component Structure', () => {
+    it('should have Tooltip component', () => {
+      expect(wrapper.findComponent({ name: 'Tooltip' }).exists()).toBe(true);
+    });
+
+    it('should have TooltipTrigger component', () => {
+      expect(wrapper.findComponent({ name: 'TooltipTrigger' }).exists()).toBe(
+        true,
+      );
+    });
+
+    it('should have TooltipContent component', () => {
+      expect(wrapper.findComponent({ name: 'TooltipContent' }).exists()).toBe(
+        true,
+      );
+    });
+  });
+
+  describe('CSS Classes', () => {
+    it('should pass side prop to TooltipContent', () => {
+      const sides = ['top', 'right', 'bottom', 'left'];
+
+      sides.forEach((side) => {
+        const sideWrapper = createWrapper({
+          text: 'Text',
+          enabled: true,
+          side,
+        });
+
+        const tooltipContent = sideWrapper.findComponent({
+          name: 'TooltipContent',
+        });
+        expect(tooltipContent.exists()).toBe(true);
+        expect(tooltipContent.props('side')).toBe(side);
+
+        sideWrapper.unmount();
+      });
+    });
+
+    it('should pass class prop to TooltipContent component', () => {
+      const tooltipContent = wrapper.findComponent({ name: 'TooltipContent' });
+      expect(tooltipContent.exists()).toBe(true);
+      expect(tooltipContent.props('class')).toContain('unnnic-tooltip-label');
+    });
   });
 
-  it('should calculate tooltip position based on element coordinates', async () => {
-    await wrapper.setProps({ side: 'right' });
+  describe('Side Validator', () => {
+    it('should validate side prop correctly', () => {
+      const validator = wrapper.vm.$options.props.side.validator;
+
+      expect(validator('top')).toBe(true);
+      expect(validator('right')).toBe(true);
+      expect(validator('bottom')).toBe(true);
+      expect(validator('left')).toBe(true);
+      expect(validator('invalid')).toBe(false);
+    });
+  });
 
-    await wrapper.vm.$nextTick();
+  describe('Props Defaults', () => {
+    it('should have correct default values', () => {
+      const defaultWrapper = createWrapper();
 
-    expect(wrapper.vm.leftPos).toBeDefined();
-    expect(wrapper.vm.topPos).toBeDefined();
+      expect(defaultWrapper.vm.$props.text).toBe('');
+      expect(defaultWrapper.vm.$props.enabled).toBe(false);
+      expect(defaultWrapper.vm.$props.forceOpen).toBe(false);
+      expect(defaultWrapper.vm.$props.side).toBe('right');
+      expect(defaultWrapper.vm.$props.maxWidth).toBe('');
+      expect(defaultWrapper.vm.$props.enableHtml).toBe(false);
+
+      defaultWrapper.unmount();
+    });
   });
 
-  it('should remove event listeners on unmount', () => {
-    const removeEventListenerSpy = vi.spyOn(window, 'removeEventListener');
+  describe('Max Width Style', () => {
+    it('should pass maxWidth prop to TooltipContent', () => {
+      const maxWidthWrapper = createWrapper({
+        text: 'Text',
+        enabled: true,
+        maxWidth: '250px',
+      });
+
+      expect(maxWidthWrapper.vm.$props.maxWidth).toBe('250px');
+
+      maxWidthWrapper.unmount();
+    });
+
+    it('should handle different maxWidth values', () => {
+      const values = ['100px', '50%', '20rem', '300px'];
+
+      values.forEach((maxWidth) => {
+        const testWrapper = createWrapper({
+          text: 'Text',
+          enabled: true,
+          maxWidth,
+        });
 
-    wrapper.unmount();
+        expect(testWrapper.vm.$props.maxWidth).toBe(maxWidth);
 
-    expect(removeEventListenerSpy).toHaveBeenCalledWith(
-      'scroll',
-      expect.any(Function),
-    );
-    expect(removeEventListenerSpy).toHaveBeenCalledWith(
-      'resize',
-      expect.any(Function),
-    );
+        testWrapper.unmount();
+      });
+    });
   });
 
-  it('should call handleResize on mouseover event', async () => {
-    const handlResizeSpy = vi.spyOn(wrapper.vm, 'handleResize');
-    await wrapper.trigger('mouseover');
-    expect(handlResizeSpy).toHaveBeenCalled();
+  describe('Component Props Types', () => {
+    it('should have correct prop types', () => {
+      const { props } = wrapper.vm.$options;
+
+      expect(props.text.type).toBe(String);
+      expect(props.enabled.type).toBe(Boolean);
+      expect(props.forceOpen.type).toBe(Boolean);
+      expect(props.side.type).toBe(String);
+      expect(props.maxWidth.type).toBe(String);
+      expect(props.enableHtml.type).toBe(Boolean);
+    });
   });
 
-  it('should render html link variation', async () => {
-    await wrapper.setProps({
-      enableHtml: true,
-      text: 'tooltip with <a data-testid="weni-link" href="https://weni.ai/" target="_blank" style="color: white;">weni</a> link',
+  describe('Enabled and ForceOpen Logic', () => {
+    it('should be disabled when enabled is false and forceOpen is false', () => {
+      const disabledWrapper = createWrapper({
+        text: 'Text',
+        enabled: false,
+        forceOpen: false,
+      });
+
+      expect(disabledWrapper.vm.$props.enabled).toBe(false);
+      expect(disabledWrapper.vm.$props.forceOpen).toBe(false);
+
+      disabledWrapper.unmount();
+    });
+
+    it('should override disabled state when forceOpen is true', () => {
+      const forceOpenWrapper = createWrapper({
+        text: 'Text',
+        enabled: false,
+        forceOpen: true,
+      });
+
+      expect(forceOpenWrapper.vm.$props.enabled).toBe(false);
+      expect(forceOpenWrapper.vm.$props.forceOpen).toBe(true);
+      expect(forceOpenWrapper.html()).toContain('unnnic-tooltip');
+
+      forceOpenWrapper.unmount();
     });
-    const link = wrapper.find('a[data-testid="weni-link"]');
-    expect(link.exists()).toBeTruthy();
   });
 });

package/src/components/index.ts

@@ -112,6 +112,20 @@ import {
   SegmentedControlContent,
 } from './ui/segmented-control';
 import PageHeader from './PageHeader/PageHeader.vue';
+import Dialog from './ui/dialog/Dialog.vue';
+import DialogContent from './ui/dialog/DialogContent.vue';
+import DialogFooter from './ui/dialog/DialogFooter.vue';
+import DialogHeader from './ui/dialog/DialogHeader.vue';
+import DialogTitle from './ui/dialog/DialogTitle.vue';
+import DialogTrigger from './ui/dialog/DialogTrigger.vue';
+import DialogClose from './ui/dialog/DialogClose.vue';
+import DrawerNext from './ui/drawer/Drawer.vue';
+import DrawerContent from './ui/drawer/DrawerContent.vue';
+import DrawerHeader from './ui/drawer/DrawerHeader.vue';
+import DrawerFooter from './ui/drawer/DrawerFooter.vue';
+import DrawerClose from './ui/drawer/DrawerClose.vue';
+import DrawerTitle from './ui/drawer/DrawerTitle.vue';
+import DrawerDescription from './ui/drawer/DrawerDescription.vue';
 
 type VueComponent = Component;
 
@@ -232,6 +246,20 @@ export const components: ComponentsMap = {
   unnnicSegmentedControlTrigger: SegmentedControlTrigger,
   unnnicSegmentedControlContent: SegmentedControlContent,
   unnnicPageHeader: PageHeader,
+  unnnicDialog: Dialog,
+  unnnicDialogContent: DialogContent,
+  unnnicDialogFooter: DialogFooter,
+  unnnicDialogHeader: DialogHeader,
+  unnnicDialogTitle: DialogTitle,
+  unnnicDialogTrigger: DialogTrigger,
+  unnnicDialogClose: DialogClose,
+  unnnicDrawerNext: DrawerNext,
+  unnnicDrawerContent: DrawerContent,
+  unnnicDrawerHeader: DrawerHeader,
+  unnnicDrawerFooter: DrawerFooter,
+  unnnicDrawerClose: DrawerClose,
+  unnnicDrawerTitle: DrawerTitle,
+  unnnicDrawerDescription: DrawerDescription,
 };
 
 export const unnnicFontSize = fontSize;
@@ -347,6 +375,20 @@ export const unnnicSegmentedControlList = SegmentedControlList;
 export const unnnicSegmentedControlTrigger = SegmentedControlTrigger;
 export const unnnicSegmentedControlContent = SegmentedControlContent;
 export const unnnicPageHeader = PageHeader;
+export const unnnicDialog = Dialog;
+export const unnnicDialogContent = DialogContent;
+export const unnnicDialogFooter = DialogFooter;
+export const unnnicDialogHeader = DialogHeader;
+export const unnnicDialogTitle = DialogTitle;
+export const unnnicDialogTrigger = DialogTrigger;
+export const unnnicDialogClose = DialogClose;
+export const unnnicDrawerNext = DrawerNext;
+export const unnnicDrawerContent = DrawerContent;
+export const unnnicDrawerHeader = DrawerHeader;
+export const unnnicDrawerFooter = DrawerFooter;
+export const unnnicDrawerClose = DrawerClose;
+export const unnnicDrawerTitle = DrawerTitle;
+export const unnnicDrawerDescription = DrawerDescription;
 
 export const UnnnicFontSize = fontSize;
 export const UnnnicFormElement = formElement;
@@ -461,3 +503,17 @@ export const UnnnicSegmentedControlList = SegmentedControlList;
 export const UnnnicSegmentedControlTrigger = SegmentedControlTrigger;
 export const UnnnicSegmentedControlContent = SegmentedControlContent;
 export const UnnnicPageHeader = PageHeader;
+export const UnnnicDialog = Dialog;
+export const UnnnicDialogContent = DialogContent;
+export const UnnnicDialogFooter = DialogFooter;
+export const UnnnicDialogHeader = DialogHeader;
+export const UnnnicDialogTitle = DialogTitle;
+export const UnnnicDialogTrigger = DialogTrigger;
+export const UnnnicDialogClose = DialogClose;
+export const UnnnicDrawerNext = DrawerNext;
+export const UnnnicDrawerContent = DrawerContent;
+export const UnnnicDrawerHeader = DrawerHeader;
+export const UnnnicDrawerFooter = DrawerFooter;
+export const UnnnicDrawerClose = DrawerClose;
+export const UnnnicDrawerTitle = DrawerTitle;
+export const UnnnicDrawerDescription = DrawerDescription;

package/src/components/ui/dialog/Dialog.vue

@@ -0,0 +1,19 @@
+<script setup lang="ts">
+import type { DialogRootEmits, DialogRootProps } from 'reka-ui';
+import { DialogRoot, useForwardPropsEmits } from 'reka-ui';
+
+defineOptions({
+  name: 'UnnnicDialog',
+});
+
+const props = defineProps<DialogRootProps>();
+const emits = defineEmits<DialogRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <DialogRoot v-bind="forwarded">
+    <slot />
+  </DialogRoot>
+</template>

package/src/components/ui/dialog/DialogClose.vue

@@ -0,0 +1,29 @@
+<script setup lang="ts">
+import type { DialogCloseProps } from 'reka-ui';
+import { DialogClose } from 'reka-ui';
+
+defineOptions({
+  name: 'UnnnicDialogClose',
+});
+
+const props = withDefaults(defineProps<DialogCloseProps>(), {
+  asChild: true,
+});
+</script>
+
+<template>
+  <DialogClose
+    class="unnnic-dialog-close"
+    v-bind="props"
+  >
+    <slot />
+  </DialogClose>
+</template>
+
+<style lang="scss" scoped>
+.unnnic-dialog-close {
+  > * {
+    width: 100%;
+  }
+}
+</style>