@central-design-system/components 3.0.0-alpha.3 → 3.0.0-alpha.4

package/src/utils/box.ts

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,131 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,56 @@
+/**
+ * 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();
+}

package/src/utils/changeCase/noCase.ts

@@ -0,0 +1,45 @@
+import { lowerCase } from './lowerCase';
+
+export interface IChangeCaseOptions {
+  splitRegexp?: RegExp | RegExp[];
+  stripRegexp?: RegExp | RegExp[];
+  delimiter?: string;
+  transform?: (part: string, index: number, parts: string[]) => string;
+}
+
+// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
+const DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+
+// Remove all non-word characters.
+const DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+
+/**
+ * Normalize the string into something other libraries can manipulate easier.
+ */
+export function noCase(input: string, options: IChangeCaseOptions = {}) {
+  const {
+    splitRegexp = DEFAULT_SPLIT_REGEXP,
+    stripRegexp = DEFAULT_STRIP_REGEXP,
+    transform = lowerCase,
+    delimiter = ' '
+  } = options;
+
+  const result = replace(replace(input, splitRegexp, '$1\0$2'), stripRegexp, '\0');
+  let start = 0;
+  let end = result.length;
+
+  // Trim the delimiter from around the output string.
+  while (result.charAt(start) === '\0') start++;
+  while (result.charAt(end - 1) === '\0') end--;
+
+  // Transform each token independently.
+  return result.slice(start, end).split('\0').map(transform).join(delimiter);
+}
+
+/**
+ * Replace `re` in the input string with the replacement value.
+ */
+function replace(input: string, re: RegExp | RegExp[], value: string) {
+  if (re instanceof RegExp) return input.replace(re, value);
+  return re.reduce((input, re) => input.replace(re, value), input);
+}

package/src/utils/changeCase/paramCase.ts

@@ -0,0 +1,11 @@
+import { noCase } from './noCase';
+import type { IChangeCaseOptions } from './noCase';
+
+export type { IChangeCaseOptions };
+
+export function paramCase(input: string, options: IChangeCaseOptions = {}) {
+  return noCase(input, {
+    delimiter: '-',
+    ...options
+  });
+}

package/src/utils/changeCase/pascalCase.ts

@@ -0,0 +1,24 @@
+import { noCase, IChangeCaseOptions } from './noCase';
+
+export type { IChangeCaseOptions };
+
+export function pascalCaseTransform(input: string, index: number) {
+  const firstChar = input.charAt(0);
+  const lowerChars = input.substr(1).toLowerCase();
+  if (index > 0 && firstChar >= '0' && firstChar <= '9') {
+    return `_${firstChar}${lowerChars}`;
+  }
+  return `${firstChar.toUpperCase()}${lowerChars}`;
+}
+
+export function pascalCaseTransformMerge(input: string) {
+  return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
+}
+
+export function pascalCase(input: string, options: IChangeCaseOptions = {}) {
+  return noCase(input, {
+    delimiter: '',
+    transform: pascalCaseTransform,
+    ...options
+  });
+}