@pequity/squirrel 6.0.14 → 6.1.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pequity/squirrel",
   "description": "Squirrel component library",
-  "version": "6.0.14",
+  "version": "6.1.1",
   "packageManager": "pnpm@9.15.5",
   "type": "module",
   "scripts": {
@@ -18,6 +18,7 @@
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build",
     "test-storybook": "test-storybook",
+    "quality": "pnpm run lint && pnpm run typecheck && pnpm run test:unit && pnpm run build",
     "prepare": "husky"
   },
   "files": [
@@ -53,30 +54,30 @@
     "@playwright/test": "^1.50.1",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@storybook/addon-a11y": "^8.5.7",
-    "@storybook/addon-actions": "^8.5.7",
-    "@storybook/addon-essentials": "^8.5.7",
-    "@storybook/addon-interactions": "^8.5.7",
-    "@storybook/addon-links": "^8.5.7",
-    "@storybook/blocks": "^8.5.7",
-    "@storybook/manager-api": "^8.5.7",
-    "@storybook/test": "^8.5.7",
-    "@storybook/test-runner": "^0.21.2",
-    "@storybook/theming": "^8.5.7",
-    "@storybook/vue3": "^8.5.7",
-    "@storybook/vue3-vite": "^8.5.7",
-    "@tanstack/vue-virtual": "3.13.0",
+    "@storybook/addon-a11y": "^8.6.0",
+    "@storybook/addon-actions": "^8.6.0",
+    "@storybook/addon-essentials": "^8.6.0",
+    "@storybook/addon-interactions": "^8.6.0",
+    "@storybook/addon-links": "^8.6.0",
+    "@storybook/blocks": "^8.6.0",
+    "@storybook/manager-api": "^8.6.0",
+    "@storybook/test": "^8.6.0",
+    "@storybook/test-runner": "^0.21.3",
+    "@storybook/theming": "^8.6.0",
+    "@storybook/vue3": "^8.6.0",
+    "@storybook/vue3-vite": "^8.6.0",
+    "@tanstack/vue-virtual": "3.13.2",
     "@types/jsdom": "^21.1.7",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^22.13.4",
+    "@types/node": "^22.13.5",
     "@vitejs/plugin-vue": "^5.2.1",
-    "@vitest/coverage-v8": "^3.0.6",
+    "@vitest/coverage-v8": "^3.0.7",
     "@vue/compiler-sfc": "3.5.13",
     "@vue/test-utils": "^2.4.6",
     "@vuepic/vue-datepicker": "11.0.1",
     "autoprefixer": "^10.4.20",
     "dayjs": "1.11.13",
-    "eslint": "^9.20.1",
+    "eslint": "^9.21.0",
     "eslint-plugin-storybook": "^0.11.3",
     "floating-vue": "5.2.2",
     "glob": "^11.0.1",
@@ -86,24 +87,24 @@
     "lint-staged": "^15.4.3",
     "lodash-es": "4.17.21",
     "make-coverage-badge": "^1.2.0",
-    "postcss": "^8.5.2",
-    "prettier": "^3.5.1",
+    "postcss": "^8.5.3",
+    "prettier": "^3.5.2",
     "prettier-plugin-tailwindcss": "^0.6.11",
     "resolve-tspaths": "^0.8.23",
     "rimraf": "^6.0.1",
-    "sass": "^1.85.0",
+    "sass": "^1.85.1",
     "semantic-release": "^24.2.3",
-    "storybook": "^8.5.7",
+    "storybook": "^8.6.0",
     "svgo": "^3.3.2",
     "tailwindcss": "^3.4.17",
     "typescript": "5.7.3",
-    "vite": "^6.1.0",
-    "vitest": "^3.0.6",
+    "vite": "^6.2.0",
+    "vitest": "^3.0.7",
     "vue": "3.5.13",
     "vue-currency-input": "3.2.1",
     "vue-router": "4.5.0",
     "vue-toastification": "2.0.0-rc.5",
-    "vue-tsc": "2.2.0"
+    "vue-tsc": "2.2.4"
   },
   "dependencies": {
     "tailwind-variants": "^0.3.1"

package/squirrel/components/p-btn/p-btn.spec.js

@@ -1,6 +1,7 @@
 import PBtn from '@squirrel/components/p-btn/p-btn.vue';
 import { sanitizeUrl } from '@squirrel/utils/sanitization';
 import { createWrapperFor } from '@tests/vitest.helpers';
+import { describe } from 'vitest';
 
 vi.mock('@squirrel/utils/sanitization', () => {
   return {
@@ -27,215 +28,282 @@ const DEFAULT_CLASSES_ARRAY = [
 ];
 
 describe('PBtn.vue', () => {
-  Object.keys(ELEMENTS_MAP).forEach((el) => {
-    const to = ELEMENTS_MAP[el];
+  describe('default button', () => {
+    Object.keys(ELEMENTS_MAP).forEach((el) => {
+      const to = ELEMENTS_MAP[el];
 
-    it.each([
-      ['primary', ['text-surface', 'bg-primary', 'hover:bg-accent', 'active:bg-p-blue-80']],
-      ['secondary', ['bg-p-gray-20', 'hover:bg-p-gray-30', 'active:bg-p-gray-40']],
-      [
-        'primary-outline',
-        ['text-p-purple-60', 'bg-p-blue-10', 'ring-1', 'ring-inset', 'ring-p-purple-60', 'hover:bg-p-gray-20'],
-      ],
-      [
-        'secondary-outline',
+      it.each([
+        ['primary', ['text-surface', 'bg-primary', 'hover:bg-accent', 'active:bg-p-blue-80']],
+        ['secondary', ['bg-p-gray-20', 'hover:bg-p-gray-30', 'active:bg-p-gray-40']],
+        [
+          'primary-outline',
+          ['text-p-purple-60', 'bg-p-blue-10', 'ring-1', 'ring-inset', 'ring-p-purple-60', 'hover:bg-p-gray-20'],
+        ],
         [
-          'text-p-purple-60',
-          'bg-surface',
-          'ring-1',
-          'ring-inset',
-          'ring-p-gray-30',
-          'hover:bg-p-blue-10',
-          'aria-selected:bg-p-blue-10',
+          'secondary-outline',
+          [
+            'text-p-purple-60',
+            'bg-surface',
+            'ring-1',
+            'ring-inset',
+            'ring-p-gray-30',
+            'hover:bg-p-blue-10',
+            'aria-selected:bg-p-blue-10',
+          ],
         ],
-      ],
-      [
-        'secondary-outline-blue',
         [
-          'text-p-purple-60',
-          'bg-surface',
-          'ring-1',
-          'ring-inset',
-          'ring-p-gray-30',
-          'hover:bg-p-blue-10',
-          'aria-selected:bg-p-blue-15',
-          'aria-selected:text-p-blue-60',
+          'secondary-outline-blue',
+          [
+            'text-p-purple-60',
+            'bg-surface',
+            'ring-1',
+            'ring-inset',
+            'ring-p-gray-30',
+            'hover:bg-p-blue-10',
+            'aria-selected:bg-p-blue-15',
+            'aria-selected:text-p-blue-60',
+          ],
         ],
-      ],
-      ['error', ['text-white', 'bg-p-red-40', 'hover:bg-p-red-50']],
-      ['success', ['text-white', 'bg-p-green-40', 'hover:bg-p-green-50']],
-      ['primary-link', ['text-primary', 'bg-transparent', 'hover:text-accent', 'underline']],
-      ['secondary-ghost', ['text-on-surface', 'hover:bg-p-gray-20']],
-    ])(`renders a ${el} of type %s`, async (type, classes) => {
+        ['error', ['text-white', 'bg-p-red-40', 'hover:bg-p-red-50']],
+        ['success', ['text-white', 'bg-p-green-40', 'hover:bg-p-green-50']],
+        ['primary-link', ['text-primary', 'bg-transparent', 'hover:text-accent', 'underline']],
+        ['secondary-ghost', ['text-on-surface', 'hover:bg-p-gray-20']],
+      ])(`renders a ${el} of type %s`, async (type, classes) => {
+        const wrapper = createWrapperFor(PBtn, {
+          props: { type },
+          attrs: { to },
+          global: {
+            stubs: { RouterLink: { template: '<section class="router-link-stub"><slot /></section>' } },
+          },
+        });
+
+        const element = wrapper.find(el);
+
+        if (el !== 'a') {
+          const slotWrapper = wrapper.find('.slot-wrapper');
+          expect(slotWrapper.classes()).toEqual(['slot-wrapper', 'empty:hidden']);
+        }
+
+        expect(classes.every((c) => element.classes().includes(c))).toBe(true);
+        expect(DEFAULT_CLASSES_ARRAY.every((c) => element.classes().includes(c))).toBe(true);
+      });
+    });
+
+    it.each([
+      ['sm', ['flex', 'items-center', 'justify-center', 'has-[.slot-wrapper:empty]:gap-0', 'gap-1']],
+      ['md', ['flex', 'items-center', 'justify-center', 'has-[.slot-wrapper:empty]:gap-0', 'gap-2']],
+      ['lg', ['flex', 'items-center', 'justify-center', 'has-[.slot-wrapper:empty]:gap-0', 'gap-2.5']],
+    ])('renders slots for content', async (size, classes) => {
       const wrapper = createWrapperFor(PBtn, {
-        props: { type },
-        attrs: { to },
-        global: {
-          stubs: { RouterLink: { template: '<section class="router-link-stub"><slot /></section>' } },
+        props: { size },
+        slots: {
+          default: `This is a button`,
         },
       });
 
-      const element = await wrapper.find(el);
+      const contentWrapper = await wrapper.find('div');
+      const button = await wrapper.find('button');
 
-      expect(classes.every((c) => element.classes().includes(c))).toBe(true);
-      expect(DEFAULT_CLASSES_ARRAY.every((c) => element.classes().includes(c))).toBe(true);
+      expect(contentWrapper.classes()).toEqual(classes);
+      expect(button.text()).toContain(`This is a button`);
     });
-  });
 
-  it('renders slots for icon and content', async () => {
-    const wrapper = createWrapperFor(PBtn, {
-      slots: {
-        default: `This is a button`,
-      },
-    });
+    it.each([
+      ['button', undefined],
+      ['a', 'https://pequity.com/'],
+      ['a', { name: 'home', params: { id: 1 } }],
+    ])('gets disabled when the element is a %s and points to %s', async (el, to) => {
+      const wrapper = createWrapperFor(PBtn, {
+        props: {
+          to,
+        },
+        attrs: {
+          disabled: true,
+        },
+        global: {
+          stubs: { RouterLink: { template: '<a class="router-link-stub"><slot /></a>' } },
+        },
+      });
 
-    const button = await wrapper.find('button');
+      const button = await wrapper.find(el);
 
-    expect(button.text()).toContain(`This is a button`);
-  });
+      await button.trigger('click');
 
-  it.each([
-    ['button', undefined],
-    ['a', 'https://pequity.com/'],
-    ['a', { name: 'home', params: { id: 1 } }],
-  ])('gets disabled when the element is a %s and points to %s', async (el, to) => {
-    const wrapper = createWrapperFor(PBtn, {
-      props: {
-        to,
-      },
-      attrs: {
-        disabled: true,
-      },
-      global: {
-        stubs: { RouterLink: { template: '<a class="router-link-stub"><slot /></a>' } },
-      },
-    });
+      if (el === 'button') {
+        expect(wrapper.emitted().click).toBeFalsy();
+      }
+      expect(button.attributes()).toHaveProperty('disabled');
+      expect(button.attributes()['aria-disabled']).toBe('true');
 
-    const button = await wrapper.find(el);
+      await wrapper.setProps({ disabled: false });
 
-    await button.trigger('click');
+      await button.trigger('click');
 
-    if (el === 'button') {
-      expect(wrapper.emitted().click).toBeFalsy();
-    }
-    expect(button.attributes()).toHaveProperty('disabled');
-    expect(button.attributes()['aria-disabled']).toBe('true');
+      if (el === 'button') {
+        expect(wrapper.emitted().click[0][0] instanceof MouseEvent).toBe(true);
+      }
+      expect(button.attributes()).not.toHaveProperty('disabled');
+      expect(button.attributes()['aria-disabled']).toBe('false');
+    });
 
-    await wrapper.setProps({ disabled: false });
+    it('has a loading state', async () => {
+      const wrapper = createWrapperFor(PBtn, {
+        props: {
+          loading: true,
+        },
+        global: {
+          stubs: { PRingLoader: { template: '<div class="loader-stub">loader</div>' } },
+        },
+      });
 
-    await button.trigger('click');
+      const button = await wrapper.find('button');
+      const loader = await wrapper.find('.loader-stub');
 
-    if (el === 'button') {
-      expect(wrapper.emitted().click[0][0] instanceof MouseEvent).toBe(true);
-    }
-    expect(button.attributes()).not.toHaveProperty('disabled');
-    expect(button.attributes()['aria-disabled']).toBe('false');
-  });
+      await button.trigger('click');
 
-  it('has a loading state', async () => {
-    const wrapper = createWrapperFor(PBtn, {
-      props: {
-        loading: true,
-      },
-      global: {
-        stubs: { PRingLoader: { template: '<div class="loader-stub">loader</div>' } },
-      },
+      expect(wrapper.emitted().click).toBeFalsy();
+      expect(button.attributes()).toHaveProperty('disabled');
+      expect(loader.exists()).toBe(true);
     });
 
-    const button = await wrapper.find('button');
-    const loader = await wrapper.find('.loader-stub');
+    it.each(['button', 'submit', 'reset'])('renders a button of native type %s', async (nativeType) => {
+      const wrapper = createWrapperFor(PBtn, { props: { nativeType } });
 
-    await button.trigger('click');
+      const button = await wrapper.find('button');
 
-    expect(wrapper.emitted().click).toBeFalsy();
-    expect(button.attributes()).toHaveProperty('disabled');
-    expect(loader.exists()).toBe(true);
-  });
+      expect(button.attributes().type).toBe(nativeType);
+    });
 
-  it.each(['button', 'submit', 'reset'])('renders a button of native type %s', async (nativeType) => {
-    const wrapper = createWrapperFor(PBtn, { props: { nativeType } });
+    it.each([
+      ['sm', ['py-1.5', 'px-3', 'rounded', 'font-medium', 'text-sm', 'leading-5']],
+      ['md', ['py-2', 'px-6', 'rounded', 'font-medium', 'text-base']],
+      ['lg', ['py-3', 'px-6', 'rounded', 'font-medium', 'text-lg']],
+    ])('renders a button of size %s', async (size, classes) => {
+      const wrapper = createWrapperFor(PBtn, { props: { size }, slots: { default: `button` } });
 
-    const button = await wrapper.find('button');
+      const button = await wrapper.find('button');
 
-    expect(button.attributes().type).toBe(nativeType);
-  });
+      expect(classes.every((c) => button.classes().includes(c))).toBe(true);
+    });
 
-  it.each([
-    ['sm', ['py-1', 'px-2', 'rounded', 'font-medium', 'text-sm']],
-    ['md', ['py-2', 'px-6', 'rounded', 'font-medium', 'text-base']],
-    ['lg', ['py-2.5', 'px-6', 'rounded', 'font-medium', 'text-lg']],
-  ])('renders a button of size %s', async (size, classes) => {
-    const wrapper = createWrapperFor(PBtn, { props: { size } });
+    it('renders an href in case it is an external link', async () => {
+      const wrapper = createWrapperFor(PBtn, {
+        props: {
+          to: 'https://pequity.com/',
+        },
+        slots: {
+          default: `This is a button`,
+        },
+      });
 
-    const button = await wrapper.find('button');
+      const a = await wrapper.find('a');
 
-    expect(classes.every((c) => button.classes().includes(c))).toBe(true);
-  });
+      expect(a.attributes().href).toBe(`sanitized-https://pequity.com/`);
+      expect(a.attributes().target).toBe('_blank');
+      expect(a.text()).toBe('This is a button');
+    });
+
+    it('renders a router link', async () => {
+      const wrapper = createWrapperFor(PBtn, {
+        props: {
+          to: { name: 'home', params: { id: 1 } },
+        },
+        slots: {
+          default: `This is a button`,
+        },
+        global: {
+          stubs: { RouterLink: { template: '<section class="router-link-stub"><slot /></section>' } },
+        },
+      });
 
-  it('renders an href in case it is an external link', async () => {
-    const wrapper = createWrapperFor(PBtn, {
-      props: {
-        to: 'https://pequity.com/',
-      },
-      slots: {
-        default: `This is a button`,
-      },
+      const routerLink = await wrapper.find('section');
+
+      expect(routerLink.classes()).toContain('router-link-stub');
+      expect(routerLink.text()).toBe('This is a button');
     });
 
-    const a = await wrapper.find('a');
+    it('sets the aria-selected attribute when the selected prop is set', async () => {
+      const wrapper = createWrapperFor(PBtn, {
+        props: {
+          selected: true,
+        },
+        slots: {
+          default: `This is a button`,
+        },
+      });
 
-    expect(a.attributes().href).toBe(`sanitized-https://pequity.com/`);
-    expect(a.attributes().target).toBe('_blank');
-    expect(a.text()).toBe('This is a button');
-  });
+      const button = await wrapper.find('button');
 
-  it('renders a router link', async () => {
-    const wrapper = createWrapperFor(PBtn, {
-      props: {
-        to: { name: 'home', params: { id: 1 } },
-      },
-      slots: {
-        default: `This is a button`,
-      },
-      global: {
-        stubs: { RouterLink: { template: '<section class="router-link-stub"><slot /></section>' } },
-      },
+      expect(button.attributes()['aria-selected']).toBe('true');
     });
 
-    const routerLink = await wrapper.find('section');
+    it('sanitizes an invalid link', async () => {
+      const wrapper = createWrapperFor(PBtn, {
+        props: {
+          to: 'javascript:evil()',
+        },
+        slots: {
+          default: `This is a button`,
+        },
+      });
+
+      const a = await wrapper.find('a');
 
-    expect(routerLink.classes()).toContain('router-link-stub');
-    expect(routerLink.text()).toBe('This is a button');
+      expect(a.text()).toBe('This is a button');
+      expect(sanitizeUrl).toHaveBeenCalledTimes(1);
+    });
   });
 
-  it('sets the aria-selected attribute when the selected prop is set', async () => {
-    const wrapper = createWrapperFor(PBtn, {
-      props: {
-        selected: true,
-      },
-      slots: {
-        default: `This is a button`,
-      },
+  describe('icon button', () => {
+    it.each([
+      ['sm', ['shrink-0', 'text-[20px]']],
+      ['md', ['shrink-0', 'text-xl']],
+      ['lg', ['shrink-0', 'text-2xl']],
+    ])('renders a button with icon of size %s', async (size, classes) => {
+      const wrapper = createWrapperFor(PBtn, {
+        props: { size, icon: 'edit' },
+        slots: { default: 'text' },
+        global: { stubs: { PIcon: true } },
+      });
+
+      const icon = await wrapper.findComponent({ name: 'PIcon' });
+
+      console.log(icon.classes());
+
+      expect(classes.every((c) => icon.classes().includes(c))).toBe(true);
     });
 
-    const button = await wrapper.find('button');
+    it.each([
+      ['sm', ['shrink-0', 'text-[20px]']],
+      ['md', ['shrink-0', 'text-xl']],
+      ['lg', ['shrink-0', 'text-2xl']],
+    ])('renders a button with a right icon of size %s', async (size, classes) => {
+      const wrapper = createWrapperFor(PBtn, {
+        props: { size, iconRight: 'edit' },
+        slots: { default: 'text' },
+        global: { stubs: { PIcon: true } },
+      });
 
-    expect(button.attributes()['aria-selected']).toBe('true');
-  });
+      const icon = await wrapper.findComponent({ name: 'PIcon' });
 
-  it('sanitizes an invalid link', async () => {
-    const wrapper = createWrapperFor(PBtn, {
-      props: {
-        to: 'javascript:evil()',
-      },
-      slots: {
-        default: `This is a button`,
-      },
+      expect(classes.every((c) => icon.classes().includes(c))).toBe(true);
     });
 
-    const a = await wrapper.find('a');
+    it.each([
+      ['sm', ['shrink-0', 'text-[20px]'], ['has-[.slot-wrapper:empty]:px-1.5']],
+      ['md', ['shrink-0', 'text-xl'], ['has-[.slot-wrapper:empty]:px-2.5']],
+      ['lg', ['shrink-0', 'text-2xl'], ['has-[.slot-wrapper:empty]:px-3']],
+    ])('renders a button with an icon without text of size %s', async (size, classes, buttonClasses) => {
+      const wrapper = createWrapperFor(PBtn, {
+        props: { size, icon: 'edit' },
+        global: { stubs: { PIcon: true } },
+      });
 
-    expect(a.text()).toBe('This is a button');
-    expect(sanitizeUrl).toHaveBeenCalledTimes(1);
+      const button = wrapper.find('button');
+      const icon = wrapper.findComponent({ name: 'PIcon' });
+
+      expect(classes.every((c) => icon.classes().includes(c))).toBe(true);
+      expect(buttonClasses.every((c) => button.classes().includes(c))).toBe(true);
+    });
   });
 });

package/squirrel/components/p-btn/p-btn.stories.js

@@ -1,4 +1,3 @@
-import Icon from '@squirrel/assets/info-circle-icon.svg?inline';
 import PBtn from '@squirrel/components/p-btn/p-btn.vue';
 import { action } from '@storybook/addon-actions';
 import { expect, within } from '@storybook/test';
@@ -101,19 +100,44 @@ export const PrimaryLink = {
   },
 };
 
-export const IconButtonSmall = {
+export const Icon = {
   render: (args) => ({
-    components: { PBtn, Icon },
+    components: { PBtn },
     setup() {
       return { args };
     },
-    template: `
-      <PBtn v-bind="args">
-        <Icon class="my-1" />
-      </PBtn>`,
+    template: ` <PBtn v-bind="args" icon="archive">Icon Button</PBtn> `,
   }),
   args: {
-    size: 'sm',
+    size: 'md',
+    type: 'secondary-outline',
+  },
+};
+
+export const IconRight = {
+  render: (args) => ({
+    components: { PBtn },
+    setup() {
+      return { args };
+    },
+    template: ` <PBtn v-bind="args" icon-right="archive">Icon Button</PBtn> `,
+  }),
+  args: {
+    size: 'md',
+    type: 'secondary-outline',
+  },
+};
+
+export const IconWithoutContent = {
+  render: (args) => ({
+    components: { PBtn },
+    setup() {
+      return { args };
+    },
+    template: ` <PBtn v-bind="args" icon-right="archive"></PBtn> `,
+  }),
+  args: {
+    size: 'md',
     type: 'secondary-outline',
   },
 };