@gitlab/ui 80.13.0 → 80.13.2

package/src/utils/is_slot_empty.spec.js

@@ -1,73 +0,0 @@
-import { mount } from '@vue/test-utils';
-import { isSlotEmpty } from './is_slot_empty';
-
-describe('is slot empty', () => {
-  const TestComponent = {
-    template: `
-      <div>
-        <slot></slot>
-      </div>
-    `,
-  };
-
-  it('should return true for empty slot', () => {
-    const PassesNothing = {
-      components: { TestComponent },
-      template: '<test-component></test-component>',
-    };
-
-    const wrapper = mount(PassesNothing);
-
-    expect(isSlotEmpty(wrapper.findComponent(TestComponent).vm, 'default')).toBe(true);
-  });
-
-  it('should return true for slot with comment', () => {
-    const PassesComment = {
-      components: { TestComponent },
-      template: '<test-component><!-- comment --></test-component>',
-    };
-
-    const wrapper = mount(PassesComment);
-
-    expect(isSlotEmpty(wrapper.findComponent(TestComponent).vm, 'default')).toBe(true);
-  });
-
-  it('should return true for slot with multiple comments', () => {
-    const PassesComment = {
-      components: { TestComponent },
-      template: '<test-component><!-- comment --><!-- comment2 --></test-component>',
-    };
-
-    const wrapper = mount(PassesComment);
-
-    expect(isSlotEmpty(wrapper.findComponent(TestComponent).vm, 'default')).toBe(true);
-  });
-
-  it('should return false for non-empty slot', () => {
-    const PassesComment = {
-      components: { TestComponent },
-      template: '<test-component>non-empty</test-component>',
-    };
-
-    const wrapper = mount(PassesComment);
-
-    expect(isSlotEmpty(wrapper.findComponent(TestComponent).vm, 'default')).toBe(false);
-  });
-
-  it.each([true, false])(
-    'should return %s for conditional slot contents based on slot-scope',
-    (shouldRender) => {
-      const PassesComment = {
-        components: { TestComponent },
-        template:
-          '<test-component><template #default="{ shouldRender }"><span v-if="shouldRender">empty</span></template></test-component>',
-      };
-
-      const wrapper = mount(PassesComment);
-
-      expect(
-        isSlotEmpty(wrapper.findComponent(TestComponent).vm, 'default', { shouldRender })
-      ).toBe(!shouldRender);
-    }
-  );
-});

package/src/utils/number_utils.spec.js

@@ -1,110 +0,0 @@
-import * as numberUtils from './number_utils';
-
-describe('number utils', () => {
-  describe('addition', () => {
-    it('adds two numbers together', () => {
-      expect(numberUtils.addition(3, 6)).toBe(9);
-    });
-  });
-
-  describe('sum', () => {
-    it('returns the sum of all arguments', () => {
-      expect(numberUtils.sum(3, 6, 7, 8, 9, 10)).toBe(43);
-    });
-  });
-
-  describe('average', () => {
-    it('returns the average of all arguments', () => {
-      expect(numberUtils.average(4, 6, 9, 12)).toBe(7.75);
-    });
-  });
-
-  describe('engineeringNotation', () => {
-    it.each`
-      input                | output
-      ${[1000]}            | ${'1k'}
-      ${[-1000]}           | ${'-1k'}
-      ${[100]}             | ${'100'}
-      ${[0.001]}           | ${'1m'}
-      ${[200000]}          | ${'200k'}
-      ${[9999999]}         | ${'10M'}
-      ${[101111]}          | ${'101k'}
-      ${[0.00099]}         | ${'990μ'}
-      ${[0.009101]}        | ${'9.1m'}
-      ${[0.0000007]}       | ${'700n'}
-      ${[0.0000007549]}    | ${'755n'}
-      ${[0.0000007549, 0]} | ${'800n'}
-      ${[0.0000007549, 4]} | ${'754.9n'}
-      ${['1,000.00']}      | ${'NaN'}
-      ${['a string']}      | ${'NaN'}
-      ${[NaN]}             | ${'NaN'}
-      ${[Infinity]}        | ${'Infinity'}
-      ${[-Infinity]}       | ${'-Infinity'}
-    `('with args $input, returns $output', ({ input, output }) => {
-      expect(numberUtils.engineeringNotation(...input)).toBe(output);
-    });
-  });
-
-  describe('modulo', () => {
-    it.each`
-      n           | divisor | result
-      ${-7}       | ${3}    | ${2}
-      ${-6}       | ${3}    | ${0}
-      ${-5}       | ${3}    | ${1}
-      ${-4}       | ${3}    | ${2}
-      ${-3}       | ${3}    | ${0}
-      ${-2}       | ${3}    | ${1}
-      ${-1}       | ${3}    | ${2}
-      ${0}        | ${3}    | ${0}
-      ${1}        | ${3}    | ${1}
-      ${2}        | ${3}    | ${2}
-      ${3}        | ${3}    | ${0}
-      ${4}        | ${3}    | ${1}
-      ${5}        | ${3}    | ${2}
-      ${6}        | ${3}    | ${0}
-      ${7}        | ${3}    | ${1}
-      ${-7}       | ${-3}   | ${-1}
-      ${-6}       | ${-3}   | ${0}
-      ${-5}       | ${-3}   | ${-2}
-      ${-4}       | ${-3}   | ${-1}
-      ${-3}       | ${-3}   | ${0}
-      ${-2}       | ${-3}   | ${-2}
-      ${-1}       | ${-3}   | ${-1}
-      ${0}        | ${-3}   | ${0}
-      ${1}        | ${-3}   | ${-2}
-      ${2}        | ${-3}   | ${-1}
-      ${3}        | ${-3}   | ${0}
-      ${4}        | ${-3}   | ${-2}
-      ${5}        | ${-3}   | ${-1}
-      ${6}        | ${-3}   | ${0}
-      ${7}        | ${-3}   | ${-2}
-      ${NaN}      | ${1}    | ${NaN}
-      ${1}        | ${NaN}  | ${NaN}
-      ${1}        | ${0}    | ${NaN}
-      ${Infinity} | ${1}    | ${NaN}
-    `('modulo($n, $divisor) === $result', ({ n, divisor, result }) => {
-      expect(numberUtils.modulo(n, divisor)).toBe(result);
-    });
-  });
-
-  describe('formatNumberToLocale', () => {
-    it('should format the provided string of either an integer or float', () => {
-      expect(numberUtils.formatNumberToLocale('1234')).toEqual('1,234');
-      expect(numberUtils.formatNumberToLocale('222222.233')).toEqual('222,222.233');
-    });
-
-    it('should not format the provided string if it contains no numbers', () => {
-      expect(numberUtils.formatNumberToLocale('aaaa')).toEqual('aaaa');
-    });
-
-    it('should use the options if they are provided', () => {
-      expect(numberUtils.formatNumberToLocale('222222.233', { minimumFractionDigits: 4 })).toEqual(
-        '222,222.2330'
-      );
-    });
-
-    it('should override the locale if one is provided', () => {
-      expect(numberUtils.formatNumberToLocale('222222.233', {}, 'de-de')).toEqual('222.222,233');
-    });
-  });
-});

package/src/utils/stories_utils.spec.js

@@ -1,18 +0,0 @@
-import { disableControls } from './stories_utils';
-
-describe('stories utils', () => {
-  describe('disableControls', () => {
-    const DISABLE_CONTROL_PARAMETER = { control: { disable: true } };
-
-    it('returns an empty object if no argument is given', () => {
-      expect(disableControls()).toEqual({});
-    });
-
-    it('returns parameters object when given an array of strings', () => {
-      expect(disableControls(['foo', 'bar'])).toEqual({
-        foo: DISABLE_CONTROL_PARAMETER,
-        bar: DISABLE_CONTROL_PARAMETER,
-      });
-    });
-  });
-});

package/src/utils/string_utils.spec.js

@@ -1,56 +0,0 @@
-import { splitAfterSymbols, getAvatarChar } from './string_utils';
-
-describe('string utils', () => {
-  describe('splitAfterSymbols', () => {
-    it.each`
-      string          | symbols                                 | result
-      ${''}           | ${[]}                                   | ${['']}
-      ${''}           | ${['']}                                 | ${['']}
-      ${''}           | ${['/']}                                | ${['']}
-      ${'/'}          | ${['/']}                                | ${['/']}
-      ${'//'}         | ${['/']}                                | ${['/', '/']}
-      ${'foo'}        | ${[]}                                   | ${['foo']}
-      ${'foo'}        | ${['/']}                                | ${['foo']}
-      ${'foo'}        | ${['']}                                 | ${['foo']}
-      ${'a/b'}        | ${['/']}                                | ${['a/', 'b']}
-      ${'a/b/c'}      | ${['/']}                                | ${['a/', 'b/', 'c']}
-      ${'a/b-c'}      | ${['/', '-']}                           | ${['a/', 'b-', 'c']}
-      ${'a/b-c'}      | ${['-', '/']}                           | ${['a/', 'b-', 'c']}
-      ${'/-/-/'}      | ${['/', '-']}                           | ${['/', '-', '/', '-', '/']}
-      ${`"'<>&/\\`}   | ${[`"`, `'`, `<`, `>`, `&`, `/`, `\\`]} | ${`"'<>&/\\`.split('')}
-      ${'some words'} | ${['om', 'ord']}                        | ${['som', 'e word', 's']}
-      ${'some words'} | ${['o', 'om']}                          | ${['so', 'me wo', 'rds']}
-      ${'some words'} | ${['om', 'o']}                          | ${['som', 'e wo', 'rds']}
-    `('given "$string" and $symbols returns $result', ({ string, symbols, result }) => {
-      const actual = splitAfterSymbols(symbols, string);
-      expect(actual).toEqual(result);
-      expect(actual.join('')).toEqual(string);
-    });
-  });
-
-  describe('Avatar name parsing', () => {
-    it('Returns first character of name', () => {
-      expect(getAvatarChar('Some Project')).toBe('S');
-    });
-
-    it('Returns empty if name is empty', () => {
-      expect(getAvatarChar('')).toBe('');
-    });
-
-    it('Returns emoji if it is first character in name', () => {
-      expect(getAvatarChar('🦊Tanuki')).toBe('🦊');
-    });
-
-    it('Returns first character if emoji is not first in name', () => {
-      expect(getAvatarChar('tanuki🦊')).toBe('T');
-    });
-
-    it('Returns zero-width joined emoji if the name starts with it', () => {
-      expect(getAvatarChar('🏴‍☠️Zero-width join')).toBe('🏴‍☠️');
-    });
-
-    it('Returns only first emoji if the name starts with multiple', () => {
-      expect(getAvatarChar('🏴‍☠️🙂Multiple Emoji')).toBe('🏴‍☠️');
-    });
-  });
-});

package/src/utils/utils.spec.js

@@ -1,156 +0,0 @@
-import {
-  isElementFocusable,
-  isElementTabbable,
-  focusFirstFocusableElement,
-  stopEvent,
-} from './utils';
-
-describe('isElementFocusable', () => {
-  const myBtn = () => document.querySelector('button');
-  const myInput = () => document.querySelector('input');
-
-  beforeEach(() => {
-    document.body.innerHTML = '';
-  });
-
-  it('should return true for a button', () => {
-    document.body.innerHTML = '<button> My Button </button>';
-
-    expect(isElementFocusable(myBtn())).toBe(true);
-  });
-
-  it('should return false for an element with a z-index of -1', () => {
-    document.body.innerHTML = '<button z-index="-1"> My Button </button>';
-
-    expect(isElementFocusable(myBtn())).toBe(false);
-  });
-
-  it('should return true for an input', () => {
-    document.body.innerHTML = '<input type="text" />';
-
-    expect(isElementFocusable(myInput())).toBe(true);
-  });
-
-  it('should return false for an input with a type hidden', () => {
-    document.body.innerHTML = '<input type="hidden" />';
-
-    expect(isElementFocusable(myInput())).toBe(false);
-  });
-
-  it('should return false for a disabled button', () => {
-    document.body.innerHTML = '<button disabled> My Button </button>';
-
-    expect(isElementFocusable(myBtn())).toBe(false);
-  });
-
-  it('should return true for an anchor tag with an href attribute', () => {
-    document.body.innerHTML = '<a href="mylink"> My Link </a>';
-    const myAnchor = document.querySelector('a');
-
-    expect(isElementFocusable(myAnchor)).toBe(true);
-  });
-
-  it('should return true for an anchor tag without an href attribute', () => {
-    document.body.innerHTML = '<a href=""> My Link </a>';
-    const myAnchor = document.querySelector('a');
-
-    expect(isElementFocusable(myAnchor)).toBe(false);
-  });
-});
-
-describe('isElementTabbable', () => {
-  const myDiv = () => document.querySelector('div');
-
-  beforeEach(() => {
-    document.body.innerHTML = '';
-  });
-
-  it('should return false for a div without tabindex', () => {
-    document.body.innerHTML = '<div> Fake button </div>';
-
-    expect(isElementTabbable(myDiv())).toBe(false);
-  });
-
-  it('should return false for a div with a tabindex less than 0', () => {
-    document.body.innerHTML = '<div tabindex="-1"> Fake button </div>';
-
-    expect(isElementTabbable(myDiv())).toBe(false);
-  });
-
-  it('should return true for a div with a tabindex equal to 0', () => {
-    document.body.innerHTML = '<div tabindex="0"> Fake button </div>';
-
-    expect(isElementTabbable(myDiv())).toBe(true);
-  });
-
-  it('should return true for a div with a tabindex greater than 0', () => {
-    document.body.innerHTML = '<div tabindex="0"> Fake button </div>';
-
-    expect(isElementTabbable(myDiv())).toBe(true);
-  });
-});
-
-describe('focusFirstFocusableElement', () => {
-  const myBtn = () => document.querySelector('button');
-  const myInput = () => document.querySelector('input');
-
-  beforeEach(() => {
-    document.body.innerHTML = '';
-  });
-
-  it('Focus the first element of the list if available', () => {
-    document.body.innerHTML = '<div><div><button></button><input /></div></div>';
-
-    focusFirstFocusableElement([myBtn(), myInput()]);
-
-    expect(document.activeElement).toBe(myBtn());
-  });
-
-  it('Focus the second element of the list if the first is not valid', () => {
-    document.body.innerHTML = '<div><div><button disabled></button><input /></div></div>';
-
-    focusFirstFocusableElement([myBtn(), myInput()]);
-
-    expect(document.activeElement).toBe(myInput());
-  });
-});
-
-describe('stopEvent', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  const event = {
-    preventDefault: jest.fn(),
-    stopPropagation: jest.fn(),
-    stopImmediatePropagation: jest.fn(),
-  };
-
-  it('calls preventDefault and stopPropagation by default', () => {
-    stopEvent(event);
-
-    expect(event.preventDefault).toHaveBeenCalledTimes(1);
-    expect(event.stopPropagation).toHaveBeenCalledTimes(1);
-    expect(event.stopImmediatePropagation).not.toHaveBeenCalled();
-  });
-
-  it('completely stops the event when stopImmediatePropagation is true', () => {
-    stopEvent(event, { stopImmediatePropagation: true });
-
-    expect(event.preventDefault).toHaveBeenCalledTimes(1);
-    expect(event.stopPropagation).toHaveBeenCalledTimes(1);
-    expect(event.stopImmediatePropagation).toHaveBeenCalledTimes(1);
-  });
-
-  it('calls event stop methods set to true', () => {
-    stopEvent(event, {
-      preventDefault: false,
-      stopPropagation: false,
-      stopImmediatePropagation: true,
-    });
-
-    expect(event.preventDefault).not.toHaveBeenCalled();
-    expect(event.stopPropagation).not.toHaveBeenCalled();
-    expect(event.stopImmediatePropagation).toHaveBeenCalledTimes(1);
-  });
-});