chili-ui 0.0.1

package/leda/utils/filterStrHelpers.test.ts

@@ -0,0 +1,345 @@
+import { getIsSentenceIncludingWords } from './filterStrHelpers';
+
+describe('getIsSentenceIncludingWords', () => {
+  describe('when a single word is searched', () => {
+    // position
+    it('should find an exact match of the word when the word is at the beginning of the sentence', () => {
+      const isSentenceIncludingWords = getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London',
+      );
+      expect(isSentenceIncludingWords).toBeTruthy();
+    });
+    it('should find an exact match of the word when the word is at the end of the sentence', () => {
+      const isSentenceIncludingWords = getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'Britain',
+      );
+      expect(isSentenceIncludingWords).toBeTruthy();
+    });
+    it('should find an exact match of the word when the word is in the middle of the sentence', () => {
+      const isSentenceIncludingWords = getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'capital',
+      );
+      expect(isSentenceIncludingWords).toBeTruthy();
+    });
+
+    // letter case
+    it('should find a match if the letter case differs', () => {
+      const isSentenceIncludingWords = getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'london',
+      );
+      expect(isSentenceIncludingWords).toBeTruthy();
+    });
+    it('should find a match if the letter case is opposite', () => {
+      const isSentenceIncludingWords = getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'CAPITAL',
+      );
+      expect(isSentenceIncludingWords).toBeTruthy();
+    });
+
+    // partial words
+    it('should find a match if the word is not finished', () => {
+      const isSentenceIncludingWords = getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'Lond',
+      );
+      expect(isSentenceIncludingWords).toBeTruthy();
+    });
+    it('should find a match if the word does not have a beginning part', () => {
+      const isSentenceIncludingWords = getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'ritain',
+      );
+      expect(isSentenceIncludingWords).toBeTruthy();
+    });
+    it('should find a match if the word is just a part', () => {
+      const isSentenceIncludingWords = getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'apita',
+      );
+      expect(isSentenceIncludingWords).toBeTruthy();
+    });
+
+    // reverse search
+    it('should not match sentence words with the passed words', () => {
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'Londonish',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'then',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'pis',
+      )).toBeFalsy();
+    });
+  });
+
+  describe('when several words are searched', () => {
+    // order
+    it('should find two words in the same order', () => {
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London capital',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London Britain',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'is of',
+      )).toBeTruthy();
+    });
+    it('should find more than two words in the same order', () => {
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London is capital',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London is the',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London is Britain',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'is the of',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'is of Britain',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'is capital of Britain',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London is the capital of Britain',
+      )).toBeTruthy();
+    });
+    it('should find more than two words in the mixed order', () => {
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London capital is',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London Great is the',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'is of the',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'Britain is the capital of Great London',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London the is capital of Great Britain',
+      )).toBeTruthy();
+    });
+    it('should find words parts regardless of letter case and order', () => {
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'ondo cap brit is',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'the lond brit',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'brit cap',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'OF LOND',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'i lo',
+      )).toBeTruthy();
+    });
+    it('should return false if there are words that the sentence do not have', () => {
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'ondo cap brit ist',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London ist the',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'londbrit',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'Londonis',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'London,',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        '.is',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'is . the',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'is,the',
+      )).toBeFalsy();
+    });
+  });
+  describe('numbers and symbols', () => {
+    it('should handle numbers', () => {
+      expect(getIsSentenceIncludingWords(
+        '123 87364 88746644',
+        '12 88',
+      )).toBeTruthy();
+    });
+    it('should handle symbols', () => {
+      expect(getIsSentenceIncludingWords(
+        '==! *** .,',
+        '* =',
+      )).toBeTruthy();
+    });
+    it('should handle regexp symbols', () => {
+      expect(getIsSentenceIncludingWords(
+        'London /is/ (the) [capital] /o(f)/i Great Britain',
+        '/i [ (the)',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        '/is/',
+      )).toBeFalsy();
+    });
+    it('should handle mixed input', () => {
+      expect(getIsSentenceIncludingWords(
+        'London is-the-capital of Great Britain',
+        'London is-the',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is-the-capital of 21 Great Britain',
+        'Great 21',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is-the-capital of 21 Great Britain',
+        '21 -',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is-the-capital of 21 Great Britain',
+        'brit -the',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is-the-capital of 21 Great.Britain',
+        'great london',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is-the-capital of 21 Great.Britain',
+        'london .b 1 -',
+      )).toBeTruthy();
+    });
+  });
+  describe('unexpected input', () => {
+    it('should return false for empty strings and spaces', () => {
+      expect(getIsSentenceIncludingWords(
+        '',
+        '',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        ' ',
+        '',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        '',
+        ' ',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        '',
+        ' ',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        ' ',
+        ' ',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        '   ',
+        '  ',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        ' ',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        '',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        '',
+        'London',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        ' ',
+        'is',
+      )).toBeFalsy();
+    });
+    it('should be insensitive to the number of spaces', () => {
+      expect(getIsSentenceIncludingWords(
+        ' London is the capital of Great Britain',
+        'lon brit capital',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain ',
+        'lon brit capital',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital  of    Great Britain',
+        'lon brit capital',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital  of    Great Britain',
+        ' lon brit capital',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital  of    Great Britain',
+        'lon brit capital ',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital  of    Great Britain',
+        ' lon    brit   capital',
+      )).toBeTruthy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        ' lon    brit   capital',
+      )).toBeTruthy();
+    });
+    // todo: handle this case in the main function
+    // eslint-disable-next-line jest/no-disabled-tests
+    it.skip('should return false for repeated words', () => {
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'great great',
+      )).toBeFalsy();
+      expect(getIsSentenceIncludingWords(
+        'London is the capital of Great Britain',
+        'london is is',
+      )).toBeFalsy();
+    });
+  });
+});

package/leda/utils/filterStrHelpers.ts

@@ -0,0 +1,85 @@
+// Possible options for filtering values in the drop-down list
+export const FILTER_RULES = {
+  smart: 'smart' as const,
+  startsWith: 'startsWith' as const,
+  includes: 'includes' as const,
+};
+
+/* value: 'Paris is the capital of France'
+   suggestion: 'paris'
+   => true
+
+   value: 'Paris is the capital of France'
+   suggestion: 'paris france'
+   => true
+*/
+export const filterByIncludes = (suggestion: string, value: string): boolean => suggestion.toLowerCase().includes(value.toLowerCase());
+
+/* value: 'Paris is the capital of France'
+   suggestion: 'paris'
+   => true
+
+   value: 'Paris is the capital of France'
+   suggestion: 'paris france'
+   => false
+*/
+export const filterByStartsWith = (suggestion: string, value: string): boolean => suggestion.toLowerCase().startsWith(value.toLowerCase());
+
+export const escapeRegexp = (string: string): string => string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/* returns true if all needles are present in hay
+*  regardless of their order
+*
+*  e.g.
+*  sentence: 'Saint Petersburg is the capital of Russia'
+*  words: 'russia saint'
+*  => true
+*
+*  sentence: 'Saint Petersburg is the capital of Russia'
+*  words: 'russia moscow'
+*  => false
+*
+*  sentence: 'Saint Petersburg is the capital of Russia'
+*  words: 'peter'
+*  => true
+*
+* sentence is a string containing words, one or more spaces and other symbols
+* words is a string containing spaces and other symbols, a word is a set of symbols bounded by spaces or string boundaries
+*/
+
+export const getIsSentenceIncludingWords = (sentence: string, words: string): boolean => {
+  if (words === '') return true;
+  if (/^\s+$/.test(words)) return false;
+  if (sentence.trim() === '') return false;
+
+  const isMultiWord = /\s+/.test(words);
+
+  if (isMultiWord) {
+    const wordsArr = words.split(/\s+/);
+    const regExpCore = wordsArr.map((el) => `(?=.*${escapeRegexp(el)})`).join('');
+    const needle = new RegExp(`^${regExpCore}.*$`, 'gi');
+
+    return needle.test(sentence);
+  }
+
+  return sentence.toLowerCase().includes(words.toLowerCase());
+};
+
+export const filterSuggestionByRule = (suggestion: string, value: string, filterRule?: keyof typeof FILTER_RULES): boolean => {
+  switch (filterRule) {
+    case FILTER_RULES.smart:
+      // "smart" search. Filters strings that contain all the values in the string from the input.
+      // Returns "true" if the string contains all values from the input, regardless of the position of the values.
+      return getIsSentenceIncludingWords(suggestion, value);
+
+    case FILTER_RULES.startsWith:
+      // filters strings that start with the string in the input
+      return filterByStartsWith(suggestion, value);
+
+    case FILTER_RULES.includes:
+      // filters strings that contain an input string, regardless of its position
+      return filterByIncludes(suggestion, value);
+    default:
+      return getIsSentenceIncludingWords(suggestion, value);
+  }
+};

package/leda/utils/generateId.ts

@@ -0,0 +1 @@
+export const generateId = (): string => Math.random().toString(36).substring(2, 8);

package/leda/utils/getIsEmptyAndRequired.ts

@@ -0,0 +1,12 @@
+import type { SomeObject } from '../commonTypes';
+import { checkIsFilled } from '../form/helpers';
+
+// checks if a required field is empty
+// it can be valid if it is the first render, or not if not the first
+export const getIsEmptyAndRequired = (
+  value: string | number | string [] | number[] | SomeObject | SomeObject[] | null | null[] | undefined,
+  isRequired: boolean | undefined,
+): boolean => {
+  if (isRequired === true) return !checkIsFilled(value);
+  return false;
+};

package/leda/utils/getWordEnding.ts

@@ -0,0 +1,31 @@
+/** Function for substituting endings.
+ * An example:
+   getPluralForm({
+     count: 5,
+     one: 'значение',
+     two: 'значения',
+     five: 'значений',
+   }) // => 'значений'
+*/
+export const getWordEnding = ({
+  count, one, two, five,
+}: { count: number, one: string, two: string, five: string }): string => {
+  let n = Math.abs(count);
+  n %= 100;
+
+  if (n >= 5 && n <= 20) {
+    return five;
+  }
+
+  n %= 10;
+
+  if (n === 1) {
+    return one;
+  }
+
+  if (n >= 2 && n <= 4) {
+    return two;
+  }
+
+  return five;
+};

package/leda/utils/guardsHelpers.ts

@@ -0,0 +1,17 @@
+interface SecondFunction<T> {
+  <S>(second: T | S): second is T,
+}
+
+interface FirstFunction {
+  <T>(first: T): SecondFunction<T>,
+}
+
+export const equals: FirstFunction = <T>(first: T) => ((second) => first === second) as SecondFunction<T>;
+
+export const less: FirstFunction = <T>(first: T) => ((second) => first < second) as SecondFunction<T>;
+
+export const greater: FirstFunction = <T>(first: T) => ((second) => first > second) as SecondFunction<T>;
+
+export const lessOrEqual: FirstFunction = <T>(first: T) => ((second) => first <= second) as SecondFunction<T>;
+
+export const greaterOrEqual: FirstFunction = <T>(first: T) => ((second) => first >= second) as SecondFunction<T>;

package/leda/utils/helpers.ts

@@ -0,0 +1,72 @@
+import type { ClassValue } from 'classnames/types';
+import classnames from 'classnames';
+import classnamesDedupe from 'classnames/dedupe';
+import type { SomeObject } from '../commonTypes';
+
+export const stringToMaxLength = (str: string, maxLength?: number) => {
+  if (maxLength != null && maxLength < str.length) {
+    return str.substring(0, maxLength);
+  }
+  return str;
+};
+
+export const getComputedTheme = <D, T>(defaultTheme: D, theme: T): D & T => ({ ...defaultTheme, ...theme });
+
+// bind ref to a class component
+export const bindClassRef = <T, C>(instance: T, current: C | undefined | null): void => {
+  if (!current || !instance) return;
+
+  Object.keys(current).forEach((field) => {
+    (instance as unknown as SomeObject)[field] = (current as unknown as SomeObject)[field];
+  });
+};
+
+// returns a string that contains classes, or undefined if no classes were passed in
+export const getClassNames = (...classNames: ClassValue[]): string | undefined => classnames(...classNames) || undefined;
+// returns a string that contains classes without duplication, or undefined if no classes were passed in
+export const getDedupedClassNames = (...classNames: ClassValue[]): string | undefined => classnamesDedupe(...classNames) || undefined;
+
+// TEST UTILS
+
+// when generating snapshots some properties are changed dynamically and snapshots are broken. To avoid this, let's remove unnecessary properties.
+const removeProp = <T extends object>(obj: T): Partial<T> => {
+  const object = { ...obj } as { props: { [x: string]: unknown }, children: unknown };
+  const forbiddenProps = [
+    'activedescendant',
+    'anchor',
+    'aria-activedescendant',
+    'aria-controls',
+    'aria-owns',
+    'calendarGuid',
+    'containerInfo',
+    'id',
+    'initialFocusedDate',
+    'optionPrefix',
+    'owns',
+    'popupSettings',
+    'ariaActiveDescendant',
+    'ariaOwns',
+    'minDate',
+    'min',
+    'aria-valuemin',
+    'location',
+    'history',
+  ];
+
+  if (object.props) {
+    Object.keys(object.props).forEach((prop) => {
+      if (forbiddenProps.includes(prop)) object.props[prop] = '';
+      // DatePicker in the calendar has a test crash every day, because the cell with class k-today is changed, let's remove this class.
+      if (prop === 'className' && object.props[prop] === 'k-today') delete object.props[prop];
+    });
+  }
+
+  if (object.children && Array.isArray(object.children)) {
+    object.children.forEach((child) => removeProp(child));
+  }
+
+  return object as unknown as Partial<T>;
+};
+
+export const fixJSON = <T extends object>(wrapperJSON: T): Partial<T> => removeProp(wrapperJSON);
+// END OF TEST UTILS

package/leda/utils/iconsDictionary.ts

@@ -0,0 +1,17 @@
+export const svgNamespacesDictionary = [
+  'arbitrage',
+  'badge',
+  'docs',
+  'empty',
+  'glyphs',
+  'mail',
+  'notifications',
+  'rat',
+  'rea',
+  'relations',
+  'scanner',
+  'service',
+  'slim',
+  'techs',
+  'transport',
+];

package/leda/utils/index.ts

@@ -0,0 +1,53 @@
+export { svgNamespacesDictionary } from './iconsDictionary';
+
+export {
+  mergeClassNames,
+} from './mergeClassNames';
+
+export { recursiveReactChildrenMap } from './recursiveReactChildrenMap';
+
+export { extractPropsFromWrapper } from './extractPropsFromWrapper';
+
+export { isElementInViewport } from './isElementInViewport';
+
+export { scrollIntoView } from './scrollIntoView';
+
+export {
+  fixJSON, getComputedTheme, getClassNames, stringToMaxLength,
+} from './helpers';
+
+export {
+  filterByIncludes, getIsSentenceIncludingWords, filterSuggestionByRule, filterByStartsWith, FILTER_RULES,
+} from './filterStrHelpers';
+
+export { bytesSizeToUnitsSize, getSizeInBytes } from './fileSizeTransformers';
+
+export { createComponentTheme } from './createComponentTheme';
+
+export { useTheme } from './useTheme';
+
+export { useElement } from './useElement';
+
+export { useProps } from './usePops';
+
+export { useValue } from './useValue';
+
+export { dispatchEvent } from './dispatchEvent';
+
+export { generateId } from './generateId';
+
+export { mergeState } from './mergeState';
+
+export { toStringOrEmpty } from './toStringOrEmpty';
+
+export { escapeRegexp } from './filterStrHelpers';
+
+export { useAdaptivePosition } from './useAdaptivePosition';
+
+export { useInterval } from './useInterval';
+
+export { checkIsTheSameObject } from './checkIsTheSameObject';
+
+export { getIsEmptyAndRequired } from './getIsEmptyAndRequired';
+
+export { useElementRef } from './useElementRef';

package/leda/utils/isElementInViewport.ts

@@ -0,0 +1,14 @@
+export function isElementInViewport(el: HTMLElement): boolean {
+  const rect = el.getBoundingClientRect();
+  const { documentElement } = document;
+
+  const viewPortHeight = window.innerHeight || (documentElement && documentElement.clientHeight);
+  const viewPortWidth = window.innerWidth || (documentElement && documentElement.clientWidth);
+
+  return (
+    rect.top >= 0
+    && rect.left >= 0
+    && rect.bottom <= (viewPortHeight || 0)
+    && rect.right <= (viewPortWidth || 0)
+  );
+}

package/leda/utils/isSymbolAllowed.ts

@@ -0,0 +1,31 @@
+import isString from 'lodash/isString';
+import { predefinedAllowedSymbols } from '../constants';
+
+export type PredefinedAllowedSymbols = keyof typeof predefinedAllowedSymbols;
+
+interface IsSymbolAllowedProps {
+  value: string,
+  allowedSymbols?: PredefinedAllowedSymbols | RegExp,
+  componentName: string,
+}
+
+export const isSymbolAllowed = (props: IsSymbolAllowedProps): boolean => {
+  const { allowedSymbols, componentName, value } = props;
+  if (!allowedSymbols || value.length === 0) return true;
+
+  if (isString(allowedSymbols)) {
+    const predefinedRegExp = predefinedAllowedSymbols[allowedSymbols];
+
+    if (!predefinedRegExp) throw new Error(`L.${componentName}: no such predefined allowedSymbols - "${allowedSymbols}"!`);
+
+    return [...value].every((symbol) => predefinedRegExp.test(symbol));
+  }
+
+  if (allowedSymbols instanceof RegExp) {
+    const regExp: RegExp = allowedSymbols;
+
+    return [...value].every((symbol) => regExp.test(symbol));
+  }
+
+  throw new Error(`L.${componentName}: allowedSymbols prop accepts only predefined string or RegExp!`);
+};