@central-design-system/components 3.0.0-alpha.5 → 3.0.0-alpha.7

package/src/utils/__test__/mocks/propFactory.mock.ts

@@ -1,88 +0,0 @@
-import { IMockDataProvider } from '@/types/vitest';
-import { ComponentObjectPropsOptions } from '@components/shims-vue';
-
-export const mockPropFactory: IMockDataProvider<
-  { props: ComponentObjectPropsOptions; source: string; defaults?: any },
-  ComponentObjectPropsOptions
->[] = [
-  {
-    name: 'propFactory',
-    initial: {
-      props: {
-        foo: String,
-        bar: Array
-      },
-      source: 'props'
-    },
-    expected: {
-      foo: {
-        source: 'props',
-        type: String
-      },
-      bar: {
-        source: 'props',
-        type: Array
-      }
-    }
-  },
-  {
-    name: 'propFactory',
-    initial: {
-      props: {
-        test: {
-          type: String,
-          default: ''
-        }
-      },
-      source: 'test'
-    },
-    expected: {
-      test: {
-        source: 'test',
-        type: String,
-        default: ''
-      }
-    }
-  },
-  {
-    name: 'propFactory',
-    initial: {
-      props: {
-        bar: {
-          type: Object,
-          default: {}
-        }
-      },
-      source: 'bar'
-    },
-    expected: {
-      bar: {
-        source: 'bar',
-        type: Object,
-        default: {}
-      }
-    }
-  },
-  {
-    name: 'propFactory',
-    initial: {
-      props: {
-        foo: {
-          type: String,
-          default: undefined
-        }
-      },
-      source: 'foo',
-      defaults: {
-        foo: 'string'
-      }
-    },
-    expected: {
-      foo: {
-        default: 'string',
-        source: 'foo',
-        type: String
-      }
-    }
-  }
-];

package/src/utils/__test__/propFactory.test.ts

@@ -1,9 +0,0 @@
-import { propsFactory } from '../propsFactory';
-import { mockPropFactory } from './mocks/propFactory.mock';
-
-describe('propFactory.ts', () => {
-  it.each(mockPropFactory)('should be props', ({ initial, expected }) => {
-    const makeProps = propsFactory(initial.props, initial.source);
-    expect(makeProps(initial.defaults)).toEqual(expected);
-  });
-});

package/src/utils/anchor.ts

@@ -1,76 +0,0 @@
-import { includes } from './';
-
-const block = ['top', 'bottom'] as const;
-const inline = ['start', 'end', 'left', 'right'] as const;
-type Tblock = typeof block[number];
-type Tinline = typeof inline[number];
-export type TAnchor =
-  | Tblock
-  | Tinline
-  | 'center'
-  | 'center center'
-  | `${Tblock} ${Tinline | 'center'}`
-  | `${Tinline} ${Tblock | 'center'}`;
-export type ParsedAnchor =
-  | { side: 'center'; align: 'center' }
-  | { side: Tblock; align: 'left' | 'right' | 'center' }
-  | { side: 'left' | 'right'; align: Tblock | 'center' };
-
-/** Parse a raw anchor string into an object */
-export function parseAnchor(anchor: TAnchor) {
-  const anchorArr = anchor.split(' ') as [Tblock | Tinline | 'center', Tblock | Tinline | 'center' | undefined];
-  const side = anchorArr[0];
-  let align = anchorArr[1];
-
-  if (!align) {
-    align = includes(block, side) ? 'start' : includes(inline, side) ? 'top' : 'center';
-  }
-
-  return {
-    side: toPhysical(side),
-    align: toPhysical(align)
-  } as ParsedAnchor;
-}
-
-export function toPhysical(str: 'center' | Tblock | Tinline) {
-  if (str === 'start') return 'left';
-  if (str === 'end') return 'right';
-  return str;
-}
-
-export function flipSide(anchor: ParsedAnchor) {
-  return {
-    side: {
-      center: 'center',
-      top: 'bottom',
-      bottom: 'top',
-      left: 'right',
-      right: 'left'
-    }[anchor.side],
-    align: anchor.align
-  } as ParsedAnchor;
-}
-
-export function flipAlign(anchor: ParsedAnchor) {
-  return {
-    side: anchor.side,
-    align: {
-      center: 'center',
-      top: 'bottom',
-      bottom: 'top',
-      left: 'right',
-      right: 'left'
-    }[anchor.align]
-  } as ParsedAnchor;
-}
-
-export function flipCorner(anchor: ParsedAnchor) {
-  return {
-    side: anchor.align,
-    align: anchor.side
-  } as ParsedAnchor;
-}
-
-export function getAxis(anchor: ParsedAnchor) {
-  return includes(block, anchor.side) ? 'y' : 'x';
-}

package/src/utils/animation.ts

@@ -1,62 +0,0 @@
-import { Box } from './box';
-
-/** @see https://stackoverflow.com/a/57876601/2074736 */
-export function nullifyTransforms(el: HTMLElement): Box {
-  const rect = el.getBoundingClientRect();
-  const style = getComputedStyle(el);
-  const tx = style.transform;
-
-  if (tx) {
-    let ta, sx, sy, dx, dy;
-    if (tx.startsWith('matrix3d(')) {
-      ta = tx.slice(9, -1).split(/, /);
-      sx = +ta[0];
-      sy = +ta[5];
-      dx = +ta[12];
-      dy = +ta[13];
-    } else if (tx.startsWith('matrix(')) {
-      ta = tx.slice(7, -1).split(/, /);
-      sx = +ta[0];
-      sy = +ta[3];
-      dx = +ta[4];
-      dy = +ta[5];
-    } else {
-      return new Box(rect);
-    }
-
-    const to = style.transformOrigin;
-    const x = rect.x - dx - (1 - sx) * parseFloat(to);
-    const y = rect.y - dy - (1 - sy) * parseFloat(to.slice(to.indexOf(' ') + 1));
-    const w = sx ? rect.width / sx : el.offsetWidth + 1;
-    const h = sy ? rect.height / sy : el.offsetHeight + 1;
-
-    return new Box({ x, y, width: w, height: h });
-  } else {
-    return new Box(rect);
-  }
-}
-
-export function animate(
-  el: Element,
-  keyframes: Keyframe[] | PropertyIndexedKeyframes | null,
-  options?: number | KeyframeAnimationOptions
-) {
-  if (typeof el.animate === 'undefined') return { finished: Promise.resolve() };
-
-  let animation: Animation;
-  try {
-    animation = el.animate(keyframes, options);
-  } catch (err) {
-    return { finished: Promise.resolve() };
-  }
-
-  if (typeof animation.finished === 'undefined') {
-    (animation as any).finished = new Promise((resolve) => {
-      animation.onfinish = () => {
-        resolve(animation);
-      };
-    });
-  }
-
-  return animation;
-}

package/src/utils/box.ts

@@ -1,39 +0,0 @@
-export class Box {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-
-  constructor({ x, y, width, height }: { x: number; y: number; width: number; height: number }) {
-    this.x = x;
-    this.y = y;
-    this.width = width;
-    this.height = height;
-  }
-
-  get top() {
-    return this.y;
-  }
-  get bottom() {
-    return this.y + this.height;
-  }
-  get left() {
-    return this.x;
-  }
-  get right() {
-    return this.x + this.width;
-  }
-}
-
-export function getOverflow(a: Box, b: Box) {
-  return {
-    x: {
-      before: Math.max(0, b.left - a.left),
-      after: Math.max(0, a.right - b.right)
-    },
-    y: {
-      before: Math.max(0, b.top - a.top),
-      after: Math.max(0, a.bottom - b.bottom)
-    }
-  };
-}

package/src/utils/cache.ts

@@ -1,12 +0,0 @@
-export function useCache() {
-  const cache: Record<string, any> = new Map();
-
-  return {
-    getCache: function (key: string, obj: any) {
-      return cache[key] || (cache[key] = obj);
-    },
-    getCacheWithFn: function (key: string, fn: () => any) {
-      return cache[key] || (cache[key] = fn());
-    }
-  };
-}

package/src/utils/changeCase/__test__/lowerCase.test.ts

@@ -1,12 +0,0 @@
-import { lowerCaseMock, localeLowerCaseMock } from './mocks/lowerCase.mock';
-import { localeLowerCase, lowerCase } from '../lowerCase';
-
-describe('lowerCase.ts', () => {
-  it.each(lowerCaseMock)('should be to lower case - #%#', ({ initial, expected }) => {
-    expect(lowerCase(initial)).toBe(expected);
-  });
-
-  it.each(localeLowerCaseMock)('should be to locale lower case - #%#', ({ initial, expected, locale }) => {
-    expect(localeLowerCase(initial, locale)).toBe(expected);
-  });
-});

package/src/utils/changeCase/__test__/mocks/lowerCase.mock.ts

@@ -1,80 +0,0 @@
-import type { IMockDataProvider } from '@/types/vitest';
-
-export const lowerCaseMock: IMockDataProvider[] = [
-  {
-    name: 'lowerCase',
-    initial: 'FOO',
-    expected: 'foo'
-  },
-  {
-    name: 'lowerCase',
-    initial: 'hEllO',
-    expected: 'hello'
-  },
-  {
-    name: 'lowerCase',
-    initial: '123BAR',
-    expected: '123bar'
-  },
-  {
-    name: 'lowerCase',
-    initial: 'ТЕКСТ',
-    expected: 'текст'
-  },
-  {
-    name: 'lowerCase',
-    initial: 'тЕкСт',
-    expected: 'текст'
-  },
-  {
-    name: 'lowerCase',
-    initial: 'Some_Foo',
-    expected: 'some_foo'
-  },
-  {
-    name: 'lowerCase',
-    initial: 'SOME-FOO',
-    expected: 'some-foo'
-  },
-  {
-    name: 'lowerCase',
-    initial: ' FOO',
-    expected: ' foo'
-  },
-  {
-    name: 'lowerCase',
-    initial: 'HI how Are You?',
-    expected: 'hi how are you?'
-  },
-  {
-    name: 'lowerCase',
-    initial: 'test string',
-    expected: 'test string'
-  },
-  {
-    name: 'lowerCase',
-    initial: '',
-    expected: ''
-  }
-];
-
-export const localeLowerCaseMock: IMockDataProvider[] = [
-  {
-    name: 'lowerCase',
-    initial: 'FOO',
-    expected: 'foo',
-    locale: 'en'
-  },
-  {
-    name: 'lowerCase',
-    initial: 'ФУУ',
-    expected: 'фуу',
-    locale: 'ru'
-  },
-  {
-    name: 'lowerCase',
-    initial: 'STRING',
-    expected: 'strıng',
-    locale: 'tr'
-  }
-];

package/src/utils/changeCase/__test__/mocks/noCase.mock.ts

@@ -1,131 +0,0 @@
-import { IMockDataProvider } from '@/types/vitest';
-
-export const noCaseMock: IMockDataProvider[] = [
-  {
-    name: 'noCase',
-    initial: 'test',
-    expected: 'test'
-  },
-  {
-    name: 'noCase',
-    initial: 'testString',
-    expected: 'test string'
-  },
-  {
-    name: 'noCase',
-    initial: 'testString_1_2_3',
-    expected: 'test string 1 2 3'
-  },
-  {
-    name: 'noCase',
-    initial: 'x_256',
-    expected: 'x 256'
-  },
-  {
-    name: 'noCase',
-    initial: 'anHTMLTag',
-    expected: 'an html tag'
-  },
-  {
-    name: 'noCase',
-    initial: 'ID123String',
-    expected: 'id123 string'
-  },
-  {
-    name: 'noCase',
-    initial: 'Id123String',
-    expected: 'id123 string'
-  },
-  {
-    name: 'noCase',
-    initial: 'foo bar123',
-    expected: 'foo bar123'
-  },
-  {
-    name: 'noCase',
-    initial: 'a1bStar',
-    expected: 'a1b star'
-  },
-  {
-    name: 'noCase',
-    initial: '  test  ',
-    expected: 'test'
-  },
-  {
-    name: 'noCase',
-    initial: 'CONSTANT_CASE ',
-    expected: 'constant case'
-  },
-  {
-    name: 'noCase',
-    initial: 'CONST123_FOO',
-    expected: 'const123 foo'
-  },
-  {
-    name: 'noCase',
-    initial: 'FOO_bar',
-    expected: 'foo bar'
-  },
-  {
-    name: 'noCase',
-    initial: 'XMLHttpRequest',
-    expected: 'xml http request'
-  },
-  {
-    name: 'noCase',
-    initial: 'IQueryAArgs',
-    expected: 'i query a args'
-  },
-  {
-    name: 'noCase',
-    initial: 'dot.case',
-    expected: 'dot case'
-  },
-  {
-    name: 'noCase',
-    initial: 'path/case',
-    expected: 'path case'
-  },
-  {
-    name: 'noCase',
-    initial: 'snake_case',
-    expected: 'snake case'
-  },
-  {
-    name: 'noCase',
-    initial: 'snake_case123',
-    expected: 'snake case123'
-  },
-  {
-    name: 'noCase',
-    initial: 'snake_case_123',
-    expected: 'snake case 123'
-  },
-  {
-    name: 'noCase',
-    initial: 'version 0.45.0',
-    expected: 'version 0 45 0'
-  },
-  {
-    name: 'noCase',
-    initial: 'version 0..78..9',
-    expected: 'version 0 78 9'
-  },
-  {
-    name: 'noCase',
-    initial: 'version 4_99/4',
-    expected: 'version 4 99 4'
-  },
-  {
-    name: 'noCase',
-    initial: 'camel2019',
-    expected: 'camel 2019',
-    options: { splitRegexp: /([a-z])([A-Z0-9])/g }
-  },
-  {
-    name: 'noCase',
-    initial: 'minifyURLs',
-    expected: 'minify urls',
-    options: { splitRegexp: /([a-z])([A-Z0-9])/g }
-  }
-];

package/src/utils/changeCase/__test__/mocks/paramCase.mock.ts

@@ -1,39 +0,0 @@
-import { IMockDataProvider } from '@/types/vitest';
-
-export const paramCaseMock: IMockDataProvider[] = [
-  {
-    name: 'paramCase',
-    initial: '',
-    expected: ''
-  },
-  {
-    name: 'paramCase',
-    initial: 'test',
-    expected: 'test'
-  },
-  {
-    name: 'paramCase',
-    initial: 'test string',
-    expected: 'test-string'
-  },
-  {
-    name: 'paramCase',
-    initial: 'Test String',
-    expected: 'test-string'
-  },
-  {
-    name: 'paramCase',
-    initial: 'TestV2',
-    expected: 'test-v2'
-  },
-  {
-    name: 'paramCase',
-    initial: 'version 1.2.10',
-    expected: 'version-1-2-10'
-  },
-  {
-    name: 'paramCase',
-    initial: 'version 1.21.0',
-    expected: 'version-1-21-0'
-  }
-];

package/src/utils/changeCase/__test__/mocks/pascalCase.mock.ts

@@ -1,46 +0,0 @@
-import { IMockDataProvider } from '@/types/vitest';
-import { pascalCaseTransformMerge } from '@components/utils';
-
-export const pascalCaseMock: IMockDataProvider[] = [
-  {
-    name: 'pascalCase',
-    initial: '',
-    expected: ''
-  },
-  {
-    name: 'pascalCase',
-    initial: 'test',
-    expected: 'Test'
-  },
-  {
-    name: 'pascalCase',
-    initial: 'test string',
-    expected: 'TestString'
-  },
-  {
-    name: 'pascalCase',
-    initial: 'Test String',
-    expected: 'TestString'
-  },
-  {
-    name: 'pascalCase',
-    initial: 'TestV2',
-    expected: 'TestV2'
-  },
-  {
-    name: 'pascalCase',
-    initial: 'version 1.2.10',
-    expected: 'Version_1_2_10'
-  },
-  {
-    name: 'pascalCase',
-    initial: 'version 1.21.0',
-    expected: 'Version_1_21_0'
-  },
-  {
-    name: 'pascalCase',
-    initial: 'version 1.21.0',
-    expected: 'Version1210',
-    options: { transform: pascalCaseTransformMerge }
-  }
-];

package/src/utils/changeCase/__test__/noCase.test.ts

@@ -1,8 +0,0 @@
-import { noCaseMock } from './mocks/noCase.mock';
-import { noCase } from '../noCase';
-
-describe('noCase.ts', () => {
-  it.each(noCaseMock)('should be to no case - #%#', ({ initial, expected, options }) => {
-    expect(noCase(initial, options)).toBe(expected);
-  });
-});

package/src/utils/changeCase/__test__/paramCase.test.ts

@@ -1,8 +0,0 @@
-import { paramCaseMock } from './mocks/paramCase.mock';
-import { paramCase } from '../paramCase';
-
-describe('paramCase.ts', () => {
-  it.each(paramCaseMock)('should be to param case - #%#', ({ initial, expected, options }) => {
-    expect(paramCase(initial, options)).toBe(expected);
-  });
-});

package/src/utils/changeCase/__test__/pascalCase.test.ts

@@ -1,8 +0,0 @@
-import { pascalCaseMock } from './mocks/pascalCase.mock';
-import { pascalCase } from '../pascalCase';
-
-describe('pascalCase.ts', () => {
-  it.each(pascalCaseMock)('should be to pascal case - #%#', ({ initial, expected, options }) => {
-    expect(pascalCase(initial, options)).toBe(expected);
-  });
-});

package/src/utils/changeCase/lowerCase.ts

@@ -1,56 +0,0 @@
-/**
- * Locale character mapping rules.
- */
-interface Locale {
-  regexp: RegExp;
-  map: Record<string, string>;
-}
-
-/**
- * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
- */
-const SUPPORTED_LOCALE: Record<string, Locale> = {
-  tr: {
-    regexp: /\u0130|\u0049|\u0049\u0307/g,
-    map: {
-      İ: '\u0069',
-      I: '\u0131',
-      İ: '\u0069'
-    }
-  },
-  az: {
-    regexp: /\u0130/g,
-    map: {
-      İ: '\u0069',
-      I: '\u0131',
-      İ: '\u0069'
-    }
-  },
-  lt: {
-    regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g,
-    map: {
-      I: '\u0069\u0307',
-      J: '\u006A\u0307',
-      Į: '\u012F\u0307',
-      Ì: '\u0069\u0307\u0300',
-      Í: '\u0069\u0307\u0301',
-      Ĩ: '\u0069\u0307\u0303'
-    }
-  }
-};
-
-/**
- * Localized lower case.
- */
-export function localeLowerCase(str: string, locale: string) {
-  const lang = SUPPORTED_LOCALE[locale.toLowerCase()];
-  if (lang) return lowerCase(str.replace(lang.regexp, (m) => lang.map[m]));
-  return lowerCase(str);
-}
-
-/**
- * Lower case as a function.
- */
-export function lowerCase(str: string) {
-  return str.toLowerCase();
-}