@weni/unnnic-system 3.12.3-alpha.5 → 3.12.3

package/src/components/ToolTip/ToolTip.vue

@@ -1,25 +1,23 @@
 <template>
-  <Tooltip
-    :disabled="!(enabled || forceOpen)"
-    :open="forceOpen || undefined"
-    data-testid="tooltip-wrapper"
+  <div
+    ref="tooltip"
+    :class="{
+      'unnnic-tooltip': enabled || forceOpen,
+      'force-open': forceOpen,
+    }"
+    @mouseover="handleResize"
   >
-    <TooltipTrigger data-testid="tooltip-trigger">
-      <slot />
-    </TooltipTrigger>
-
-    <TooltipContent
+    <slot />
+    <span
+      v-show="enabled || forceOpen"
+      ref="label"
       :class="['unnnic-tooltip-label', `unnnic-tooltip-label-${side}`]"
-      :style="{ maxWidth: maxWidth }"
-      :side="side"
-      data-testid="tooltip-content"
+      :style="{ maxWidth: maxWidth, left: leftPos, top: topPos }"
+      data-testid="tooltip-label"
     >
       <template v-if="enableHtml">
         <!-- eslint-disable-next-line vue/no-v-html -->
-        <section
-          v-html="text"
-          data-testid="tooltip-html-content"
-        ></section>
+        <section v-html="text"></section>
       </template>
       <template
         v-for="(line, index) in text.split('\n')"
@@ -29,20 +27,22 @@
         {{ line }}
         <br />
       </template>
-    </TooltipContent>
-  </Tooltip>
+
+      <template v-if="shortcutText">
+        <span
+          class="unnnic-tooltip-label-shortcut"
+          data-testid="tooltip-label-shortcut"
+        >
+          {{ shortcutText }}
+        </span>
+      </template>
+    </span>
+  </div>
 </template>
 
 <script>
-import { Tooltip, TooltipContent, TooltipTrigger } from '../ui/tooltip';
-
 export default {
   name: 'UnnnicTooltip',
-  components: {
-    Tooltip,
-    TooltipTrigger,
-    TooltipContent,
-  },
   props: {
     text: {
       type: String,
@@ -67,10 +67,162 @@ export default {
       type: String,
       default: '',
     },
+    shortcutText: {
+      type: String,
+      default: null,
+    },
     enableHtml: {
       type: Boolean,
       default: false,
     },
   },
+  data() {
+    return {
+      topPos: null,
+      leftPos: null,
+    };
+  },
+  watch: {
+    side() {
+      this.getRightPost(this.$refs.tooltip);
+    },
+  },
+  mounted() {
+    this.handleResize();
+
+    window.addEventListener('scroll', this.handleResize);
+    window.addEventListener('resize', this.handleResize);
+  },
+  unmounted() {
+    window.removeEventListener('scroll', this.handleResize);
+    window.removeEventListener('resize', this.handleResize);
+  },
+  methods: {
+    handleResize() {
+      this.getRightPost(this.$refs.tooltip);
+    },
+    getRightPost(element) {
+      const elementPos = element.getBoundingClientRect();
+
+      if (element && this.$refs.label) {
+        if (this.side === 'right') {
+          this.leftPos = `${elementPos.x + elementPos.width + 8}px`;
+          this.topPos = `${elementPos.y + elementPos.height / 2 - this.$refs.label.offsetHeight / 2}px`;
+        } else if (this.side === 'left') {
+          this.leftPos = `${elementPos.x - this.$refs.label.offsetWidth - 8}px`;
+          this.topPos = `${elementPos.y + elementPos.height / 2 - this.$refs.label.offsetHeight / 2}px`;
+        } else if (this.side === 'top') {
+          this.leftPos = `${elementPos.x + elementPos.width / 2 - this.$refs.label.clientWidth / 2}px`;
+          this.topPos = `${elementPos.y - this.$refs.label.offsetHeight - 8}px`;
+        } else if (this.side === 'bottom') {
+          this.leftPos = `${elementPos.x + elementPos.width / 2 - this.$refs.label.clientWidth / 2}px`;
+          this.topPos = `${elementPos.y + elementPos.height + 8}px`;
+        }
+      }
+    },
+  },
 };
 </script>
+
+<style lang="scss" scoped>
+@use '@/assets/scss/unnnic' as *;
+
+.unnnic-tooltip {
+  position: relative;
+  display: inline-block;
+  overflow-wrap: break-word;
+}
+
+.unnnic-tooltip-label {
+  z-index: 1;
+  visibility: hidden;
+  text-align: center;
+  position: fixed;
+  width: max-content;
+  min-width: 2 * $unnnic-font-size;
+  box-sizing: border-box;
+  width: auto;
+  display: flex;
+  justify-content: center;
+  gap: $unnnic-spacing-xs;
+  align-items: center;
+
+  background-color: $unnnic-color-neutral-black;
+  color: $unnnic-color-neutral-snow;
+  border-radius: $unnnic-border-radius-sm;
+  padding: $unnnic-inset-nano;
+  box-shadow: $unnnic-shadow-level-near;
+  font-size: $unnnic-font-size-body-md;
+  font-family: $unnnic-font-family-secondary;
+  font-weight: $unnnic-font-weight-regular;
+  line-height: ($unnnic-font-size-body-md + $unnnic-line-height-medium);
+
+  &::after {
+    content: '';
+    position: absolute;
+    border-width: 5px;
+    border-style: solid;
+  }
+
+  &-top {
+    position: fixed;
+    &::after {
+      top: 100%;
+      left: 50%;
+      margin-left: -5px;
+      border-color: $unnnic-color-neutral-black transparent transparent
+        transparent;
+    }
+  }
+
+  &-bottom {
+    position: fixed;
+    &::after {
+      bottom: 100%;
+      left: 50%;
+      margin-left: -5px;
+      border-color: transparent transparent $unnnic-color-neutral-black
+        transparent;
+    }
+  }
+  &-right {
+    position: fixed;
+    &::after {
+      top: 50%;
+      right: 100%;
+      margin-top: -5px;
+      border-color: transparent $unnnic-color-neutral-black transparent
+        transparent;
+    }
+  }
+  &-left {
+    position: fixed;
+    &::after {
+      top: 50%;
+      left: 100%;
+      margin-top: -5px;
+      border-color: transparent transparent transparent
+        $unnnic-color-neutral-black;
+    }
+  }
+
+  &-shortcut {
+    background-color: $unnnic-color-neutral-darkest;
+    border-radius: $unnnic-border-radius-sm;
+    padding: calc($unnnic-inset-nano / 2) $unnnic-inset-nano;
+  }
+}
+
+.unnnic-tooltip.force-open {
+  .unnnic-tooltip-label {
+    visibility: visible;
+  }
+}
+
+.unnnic-tooltip:hover {
+  .unnnic-tooltip-label {
+    visibility: visible;
+    width: auto;
+  }
+}
+</style>

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

@@ -3,380 +3,102 @@ import { mount } from '@vue/test-utils';
 
 import ToolTip from '../ToolTip.vue';
 
-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,
-      },
-    },
-  });
+const createWrapper = (props) => {
+  return mount(ToolTip, { props });
 };
 
 describe('ToolTip', () => {
   let wrapper;
-
   beforeEach(() => {
-    wrapper = createWrapper({ text: 'Tooltip text', enabled: true });
+    wrapper = createWrapper({ text: 'Text', enabled: true });
   });
 
-  afterEach(() => {
-    if (wrapper) {
-      wrapper.unmount();
-    }
+  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);
   });
 
-  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 display the tooltip when enabled is true', async () => {
+    const tooltipLabel = wrapper.find('[data-testid="tooltip-label"]');
+    expect(tooltipLabel.isVisible()).toBe(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');
+  it('should force open the tooltip when forceOpen is true', async () => {
+    await wrapper.setProps({ enabled: false, forceOpen: true });
 
-      maxWidthWrapper.unmount();
-    });
-
-    it('should accept enableHtml prop', () => {
-      const htmlWrapper = createWrapper({
-        text: 'Text',
-        enableHtml: true,
-      });
-
-      expect(htmlWrapper.vm.$props.enableHtml).toBe(true);
-
-      htmlWrapper.unmount();
-    });
-  });
-
-  describe('Boolean Props', () => {
-    it('should handle enabled false', () => {
-      const disabledWrapper = createWrapper({
-        text: 'Text',
-        enabled: false,
-      });
-
-      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);
-    });
+    const tooltipLabel = wrapper.find('[data-testid="tooltip-label"]');
+    expect(tooltipLabel.isVisible()).toBe(true);
   });
 
-  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');
+  it('should position the tooltip correctly based on the side prop', async () => {
+    const sideValues = ['top', 'right', 'bottom', 'left'];
 
-      plainWrapper.unmount();
-    });
-
-    it('should accept multiline text via prop', () => {
-      const multilineWrapper = createWrapper({
-        text: 'First line\nSecond line\nThird line',
-        enabled: true,
-      });
-
-      expect(multilineWrapper.vm.$props.text).toBe(
-        'First line\nSecond line\nThird line',
-      );
-
-      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();
-    });
-  });
-
-  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',
-      });
-
-      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,
-      );
-    });
+    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}`);
+    }
   });
 
-  describe('CSS Classes', () => {
-    it('should pass side prop to TooltipContent', () => {
-      const sides = ['top', 'right', 'bottom', 'left'];
+  it('should split tooltip text into multiple lines', async () => {
+    await wrapper.setProps({ text: 'First line\nSecond line' });
 
-      sides.forEach((side) => {
-        const sideWrapper = createWrapper({
-          text: 'Text',
-          enabled: true,
-          side,
-        });
+    const tooltipLabel = wrapper.find('[data-testid="tooltip-label"]');
 
-        const tooltipContent = sideWrapper.findComponent({
-          name: 'TooltipContent',
-        });
-        expect(tooltipContent.exists()).toBe(true);
-        expect(tooltipContent.props('side')).toBe(side);
+    expect(tooltipLabel.text()).toContain('First line');
+    expect(tooltipLabel.text()).toContain('Second line');
 
-        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');
-    });
+    const brElements = tooltipLabel.findAll('br');
+    expect(brElements.length).toBe(2);
   });
 
-  describe('Side Validator', () => {
-    it('should validate side prop correctly', () => {
-      const validator = wrapper.vm.$options.props.side.validator;
+  it('should display shortcutText when provided', async () => {
+    await wrapper.setProps({ shortcutText: 'Ctrl+C' });
 
-      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);
-    });
+    const tooltipShortcut = wrapper.find(
+      '[data-testid="tooltip-label-shortcut"]',
+    );
+    expect(tooltipShortcut.exists()).toBe(true);
+    expect(tooltipShortcut.text()).toBe('Ctrl+C');
   });
 
-  describe('Props Defaults', () => {
-    it('should have correct default values', () => {
-      const defaultWrapper = createWrapper();
+  it('should calculate tooltip position based on element coordinates', async () => {
+    await wrapper.setProps({ side: 'right' });
 
-      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);
+    await wrapper.vm.$nextTick();
 
-      defaultWrapper.unmount();
-    });
+    expect(wrapper.vm.leftPos).toBeDefined();
+    expect(wrapper.vm.topPos).toBeDefined();
   });
 
-  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,
-        });
+  it('should remove event listeners on unmount', () => {
+    const removeEventListenerSpy = vi.spyOn(window, 'removeEventListener');
 
-        expect(testWrapper.vm.$props.maxWidth).toBe(maxWidth);
+    wrapper.unmount();
 
-        testWrapper.unmount();
-      });
-    });
+    expect(removeEventListenerSpy).toHaveBeenCalledWith(
+      'scroll',
+      expect.any(Function),
+    );
+    expect(removeEventListenerSpy).toHaveBeenCalledWith(
+      'resize',
+      expect.any(Function),
+    );
   });
 
-  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 call handleResize on mouseover event', async () => {
+    const handlResizeSpy = vi.spyOn(wrapper.vm, 'handleResize');
+    await wrapper.trigger('mouseover');
+    expect(handlResizeSpy).toHaveBeenCalled();
   });
 
-  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();
+  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',
     });
+    const link = wrapper.find('a[data-testid="weni-link"]');
+    expect(link.exists()).toBeTruthy();
   });
 });