intelicoreact 1.8.3 → 1.8.5

package/dist/Functions/usePasswordChecker.jsx

@@ -0,0 +1,128 @@
+import cn from 'classnames';
+
+import { useState } from 'react';
+
+export default function usePasswordChecker({ label = 'Password must:' } = {}) {
+  const [checkRules, setCheckRules] = useState([]);
+  const addCheckRule = data => setCheckRules(state => [...state, data]);
+  const handleCheckRule = (type, props = {}, value = '') => {
+    const { min, max } = props;
+
+    switch (type) {
+      case 'len':
+        if (min && value.length < min) return false;
+        if (max && value.length > max) return false;
+        return true;
+
+      case 'lowerCaseContains': {
+        const toUpperCase = value.slice().toUpperCase().split('');
+        const original = value.slice().split('');
+
+        return original.reduce((isMatch, char, i) => {
+          if (char !== toUpperCase[i]) isMatch = true;
+
+          return isMatch;
+        }, false);
+      }
+
+      case 'upperCaseContains': {
+        const toLowerCase = value.slice().toLowerCase().split('');
+        const original = value.slice().split('');
+
+        return original.reduce((isMatch, char, i) => {
+          if (char !== toLowerCase[i]) isMatch = true;
+
+          return isMatch;
+        }, false);
+      }
+
+      case 'numberContains': {
+        const original = value.slice().split('');
+        return original.reduce((isMatch, char) => {
+          if (Number.isInteger(Number.parseInt(char, 10))) isMatch = true;
+
+          return isMatch;
+        }, false);
+      }
+
+      case 'specialContains': {
+        const original = value.slice().split('');
+        return original.reduce((isMatch, char) => {
+          if (!Number.isInteger(Number.parseInt(char, 10)) && !char.match(/[a-z]/i))
+            isMatch = true;
+
+          return isMatch;
+        }, false);
+      }
+
+      default:
+        return false;
+    }
+  };
+  const testCheckRules = (value) => {
+    let result = true;
+
+    setCheckRules((state) => {
+      const rules = [...state];
+      return rules.map((rule) => {
+        const isMatch = handleCheckRule(rule.type, rule.props, value);
+        if (!isMatch) result = false;
+
+        return { ...rule, isMatch };
+      });
+    });
+
+    return result;
+  };
+
+  const renderPasswordChecker = () => {
+    return (
+      <div className="password-checker">
+        <div className="password-checker__header">
+          <label className="password-checker__header-label">
+            {' '}
+            {label}
+            {' '}
+          </label>
+          {' '}
+        </div>
+        {' '}
+        <div className="password-checker__body">
+          {' '}
+          {checkRules.map(({ icon, text, isMatch, key }) => (
+            <div
+              key={key}
+              className={cn('password-checker__body-item', {
+                'password-checker__body-item--match':
+                  isMatch && isMatch !== null,
+                'password-checker__body-item--dont-match':
+                  !isMatch && isMatch !== null,
+              })}
+            >
+              <div className="password-checker__body-item__icon">
+                {' '}
+                {icon}
+                {' '}
+              </div>
+              {' '}
+              <div className="password-checker__body-item__text">
+                {' '}
+                {text}
+                {' '}
+              </div>
+              {' '}
+            </div>
+          ))}
+          {' '}
+        </div>
+        {' '}
+      </div>
+    );
+  };
+
+  return {
+    addCheckRule,
+    testCheckRules,
+    renderPasswordChecker,
+  };
+}

package/dist/Functions/utils.jsx

@@ -0,0 +1,492 @@
+import moment from 'moment-timezone';
+
+import { useEffect } from 'react';
+
+import { DEFAULT_COLORS, OS } from '../Constants/index.constants';
+
+export const uuid = () => Date.now().toString(36) + Math.random().toString(36).substring(2);
+
+export function getIsOnlyAnObject(input) {
+  return (
+    typeof input === 'object' // "отбивает" примитивы и функции
+    && input instanceof Object // "отбивает" null
+    && !Array.isArray(input) // "отбивает" массивы
+    && !(input instanceof Set) // "отбивает" сеты
+    && !(input instanceof Map) // "отбивает" мапы
+  );
+}
+
+export function handleObjectChange(updateObject, updateFunction) {
+  return (data, prop = '', isNumber) => {
+    let value;
+    if (data?.target) {
+      value
+        = data.target.type === 'checkbox'
+          ? data.target.checked
+          : data.target.value;
+    }
+    else {
+      value = data;
+    }
+
+    value = isNumber ? Number(value) : value;
+
+    const props = prop.split('.');
+    const currentObject = props.reduce((res, chapter, index) => {
+      if (props.length !== index + 1) res = res[chapter];
+      return res;
+    }, updateObject);
+
+    currentObject[props.pop()] = value;
+    updateFunction();
+  }
+}
+
+export function useOutsideToggle(ref, setOut, open) {
+  function handleClickOutside(event) {
+    if (ref.current && !ref.current.contains(event.target)) {
+      setOut(open);
+    }
+  }
+  useEffect(() => {
+    document.addEventListener('mouseup', handleClickOutside);
+    return () => {
+      // Unbind the event listener on clean up
+      document.removeEventListener('mouseup', handleClickOutside);
+    };
+  }, [ref]);
+}
+
+// export const clone = obj => {
+//   const data = obj instanceof Array ? [] : {};
+//   for (const i in obj) data[i] = typeof obj[i] === 'object' && obj[i] != null ? clone(obj[i]) : obj[i];
+//   return data;
+// };
+// ! Этот правильнее
+export function clone(input) {
+  if (input === null || typeof input !== 'object') return input;
+  const data = Array.isArray(input) ? [] : {};
+  for (const i in input) data[i] = clone(input[i]);
+  return data;
+}
+
+export async function getResponseClone(res) {
+  return await (typeof res?.clone === 'function' ? res.clone() : clone(res))
+}
+
+// TimeUtils
+export function transformUTCTimeToLocal(date, format = 'YYYY-MM-DD HH:mm:ss') {
+  if (!date) return;
+  const utcDate = moment.utc(date).toDate();
+  return moment(utcDate, format).local().format(format);
+}
+export function transformLocalTimeToUTC(date, format = 'YYYY-MM-DD HH:mm:ss') {
+  if (!date) return;
+  return moment(date, format).utc().format(format);
+}
+export function transformUTCHoursToLocal(time, format = 'HH:mm:ss') {
+  if (!time) return;
+  const splitedTime = time.split(':');
+  const offset = moment().utcOffset();
+  let HH = Number(splitedTime[0]);
+  let mm = Number(splitedTime[1]);
+  const ss = splitedTime[2];
+  mm = mm + offset;
+  while (mm > 59) {
+    mm -= 60;
+    HH += 1;
+  }
+  if (HH > 23) HH -= 24;
+  while (mm < 0) {
+    mm += 60;
+    HH -= 1;
+  }
+  if (HH < 0) HH += 24;
+  return `${HH}:${mm}:${ss}`;
+}
+
+// ? Намерянно значением по умолчанию назначаю самый информационно-маленький паттерн
+export function transformDateOrTimeOrTogetherToFormat(
+  data,
+  outputFormat = 'HH:mm',
+  additional,
+) {
+  const ERROR_VALUE = 'Invalid date';
+  const ERROR_MESSGE = `Invalid input data for ${outputFormat} format`;
+  const { parseFormat, isReturnAsMomentInstance } = getIsOnlyAnObject(
+    additional,
+  )
+    ? additional
+    : {};
+
+  if (typeof data !== 'string' && typeof data !== 'number') {
+    return isReturnAsMomentInstance ? moment('error') : ERROR_MESSGE;
+  }
+
+  // ? Игнорируем parseFormat, если data пришла как timestamp или если parseFormat не строка
+  const momentArgs = [
+    data,
+    ...(!Number.isNaN(Number(data)) || typeof parseFormat === 'string'
+      ? []
+      : [parseFormat]),
+  ];
+
+  // ? Задача получить moment-экземпляр, валидный либо невалидный
+  const momentInstance = (() => {
+    let instance = moment(...momentArgs);
+
+    // ? Проверяем валидность moment-экземпляр-а путем попытки привести его к выходному формату
+    // ? Попадем в этот кейс если
+    // ?   - data это timestamp
+    // ?   - data это строка в формате date-time
+    // ?   - data это строка в формате date (в этом случае время выставится 00:00:00)
+    if (instance.format(outputFormat) !== ERROR_VALUE) {
+      return instance;
+    }
+    // ? Если же приведение не удалось, то предполагаем, что data пришла в формате time
+    // ? В этом случае создадим объект от текущей даты, распарсим data и установим время
+    // ? Корректно обработаются паттерны: 'HH*mm', 'HH*mm*ss', 'HH*mm*ss*любое_количество_ms', где * - любой разделитель
+    else if (/^\d\d.\d\d/.test(data)) {
+      instance = moment();
+      const symbols = data.split('');
+
+      const timeArr = symbols
+        .reduce(
+          (acc, symbol, idx) => {
+            if (Number.isNaN(Number(symbol))) {
+              if (acc.group) acc.result.push(acc.group);
+              acc.group = '';
+            }
+            else {
+              acc.group = `${acc.group}${symbol}`;
+            }
+            if (idx === symbols.length - 1 && acc.group)
+              acc.result.push(acc.group);
+            return acc;
+          },
+          { result: [], group: '' },
+        )
+        // ? reverse используется исключительно для того, чтобы после можно было использовать метод pop, а не shift,
+        // ? т.к. методы добавления/извлечения относительно конца массива работают быстрее,
+        // ? чем аналогичные относительно начала массива
+        .result
+        .reverse();
+
+      instance.hours(Number(timeArr.pop()));
+      instance.minutes(Number(timeArr.pop()));
+      instance.seconds(timeArr.length ? Number(timeArr.pop()) : 0);
+      instance.milliseconds(timeArr.length ? Number(timeArr.pop()) : 0);
+    }
+    else {
+      instance = moment('error');
+    } // ? Иначе создаем заведомо невалидный moment-экземпляр
+
+    return instance;
+  })();
+
+  if (isReturnAsMomentInstance) return momentInstance;
+
+  const output = momentInstance.format(outputFormat);
+  return output === ERROR_VALUE ? ERROR_MESSGE : output;
+}
+
+// ? Намерянно значением по умолчанию назначаю самый информационно-маленький паттерн
+export function transformDateOrTimeOrTogetherToFormattedLocal(
+  data,
+  outputFormat = 'HH:mm',
+  additional,
+) {
+  const ERROR_VALUE = 'Invalid date';
+  const ERROR_MESSGE = `Invalid input data for ${outputFormat} format`;
+
+  if (additional && !getIsOnlyAnObject(additional)) {
+    throw new Error(
+      'Bad additional [transformDateOrTimeOrTogetherToFormattedLocal]',
+    );
+  }
+
+  const compositeAdditional = {
+    ...(additional || {}),
+    isReturnAsMomentInstance: true,
+  };
+  const date = transformDateOrTimeOrTogetherToFormat(
+    data,
+    outputFormat,
+    compositeAdditional,
+  );
+
+  const dateWithLocale = date.add(moment().utcOffset(), 'minutes');
+  const output = dateWithLocale.format(outputFormat);
+
+  return output === ERROR_VALUE ? ERROR_MESSGE : output;
+}
+
+// принимает обьект и массив ключей обьекта
+// возвращает обьект с теми полями, которых нет в массиве ключей
+export function omitKeys(obj = {}, keys = []) {
+  return keys.reduce((acc, key) => {
+    const { [key]: omit, ...rest } = acc;
+    return rest;
+  }, obj)
+}
+
+export function logout() {
+  window.localStorage.removeItem('accessToken');
+  window.localStorage.removeItem('tokenExpires');
+  window.location.reload();
+}
+
+export function getStyles(el, prop) {
+  if (!el) return null;
+  if (!prop) return window.getComputedStyle(el);
+  return window.getComputedStyle(el).getPropertyValue(prop);
+}
+
+export function getColorById(id, colors) {
+  if (!id) return '#FF7D00';
+
+  const idToArr = Array.from(id);
+  const colorsArr = colors && colors.length > 0 ? colors : DEFAULT_COLORS;
+
+  let number = idToArr.reduce((acc, item) => {
+    if (Number(item)) {
+      return acc + Number(item);
+    }
+    return acc;
+  }, 0);
+
+  while (number >= colorsArr.length) {
+    number -= colorsArr.length;
+  }
+
+  return colorsArr[number];
+}
+
+export function debounce(fn, ms) {
+  let id = null;
+  return (...args) => {
+    clearTimeout(id);
+    id = setTimeout(() => {
+      clearTimeout(id);
+      fn(...args);
+    }, ms);
+  };
+}
+
+export function throttle(fn, ms) {
+  let id = null;
+  return (...args) => {
+    if (id) return;
+    fn(...args);
+    id = setTimeout(() => {
+      clearTimeout(id);
+      id = null;
+    }, ms);
+  };
+}
+
+export function addBitDepthPoints(value, step = 3) {
+  // содержит ли value точку
+  const isFraction = value?.includes('.');
+
+  // взять строку до точки
+  const valueBeforeDot = isFraction
+    ? value?.slice(0, value?.indexOf('.'))
+    : value;
+
+  // расстановка запятых после каждой 3й цифры с конца
+  const intPart = valueBeforeDot
+    .split('')
+    .reverse()
+    .reduce(
+      (acc, item, idx) =>
+        idx % step === 0 && idx !== 0 ? [...acc, ',', item] : [...acc, item],
+      [],
+    )
+    .reverse()
+    .join('');
+
+  return isFraction ? intPart + value?.slice(value?.indexOf('.')) : intPart;
+}
+
+export function changeMeta(key, items = []) {
+  const defaultMeta = items.find(i => i.key === 'default');
+
+  if (key) {
+    const item = items.find(i => i.key === key);
+    document.title = item?.title ?? defaultMeta?.title;
+    document
+      .querySelector('meta[name="description"]')
+      .setAttribute('content', item?.description ?? defaultMeta?.description);
+  }
+}
+
+export function firstLetterCapital(str) {
+  return typeof str === 'string'
+    ? `${str.charAt(0).toUpperCase()}${str.slice(1)}`
+    : str
+}
+export const capitalized = firstLetterCapital;
+
+export function checkedRef(ref) {
+  return ref ? (typeof ref === 'function' ? node => ref(node) : ref) : null
+}
+
+export function downloadEmulation(data, filename, type = 'image/*') {
+  const file = new Blob([data], { type });
+  if (window.navigator.msSaveOrOpenBlob) {
+    // IE10+
+    window.navigator.msSaveOrOpenBlob(file, filename);
+  }
+  else {
+    // Others
+    const a = document.createElement('a');
+    const url = URL.createObjectURL(file);
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    setTimeout(() => {
+      document.body.removeChild(a);
+      window.URL.revokeObjectURL(url);
+    }, 0);
+  }
+}
+
+export async function downloadFile({ url, name, type = null }) {
+  const response = await fetch(url).then(async res => ({
+    data: await res.blob(),
+    type: type ?? res.headers.get('content-type'),
+  }));
+  downloadEmulation(response.data, name, response.type);
+}
+
+export function compare(first, second, keys = []) {
+  // ? Если типы НЕ равны - не равны априори
+  if (typeof first !== typeof second) return false;
+  // ? Если ответы на вопрос "массив ли?" не равны, то не равны и типы, значит тоже не равны априори
+  if (Array.isArray(first) !== Array.isArray(second)) return false;
+  // ? Если прошли if-ку - типы условно равны, можем оценивать тип лишь одного параметра, это будет справедливо и для второго
+
+  // ? Если примитивы - просто сравниваем. Кейс с null обработан тут.
+  if (!(first instanceof Object)) return first === second;
+
+  // ? Если НЕ приметивы - не важно массив или нет, методы объекта для массива тоже доступны
+
+  const getComparationStructure = (data) => {
+    if (typeof data === 'function') return data.toString();
+    if (!(data instanceof Object)) return data;
+
+    return Object.entries(data)
+      .sort((a, b) => (a[0]).localeCompare(b[0]))
+      .map(([key, value]) => ([key, getComparationStructure(data[key])]));
+  };
+
+  // ? Получаем структуры для сравнения (с учетом глубины) - массивы массивов, сортируем по ключам,
+  const structureForComparingOfFirst = getComparationStructure(first);
+  const structureForComparingOfSecond = getComparationStructure(second);
+
+  return (JSON.stringify(structureForComparingOfFirst) === JSON.stringify(structureForComparingOfSecond));
+}
+
+// Set Carret to the End of Input
+export function setCarretToEnd(input) {
+  setTimeout(() => {
+    const tmp = input.value;
+    input.value = '';
+    input.value = tmp;
+  }, 10);
+}
+
+export function compareAlphabetical(a, b, key = 'label') {
+  let item1 = a?.[key];
+  let item2 = b?.[key];
+
+  if (typeof item1 !== 'string' || typeof item2 !== 'string') return 0;
+
+  item1 = item1?.toLowerCase();
+  item2 = item2?.toLowerCase();
+
+  if (item1 < item2) {
+    return -1;
+  }
+  if (item1 > item2) {
+    return 1;
+  }
+  return 0;
+}
+
+export function getBase64(file) {
+  if (file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.readAsDataURL(file);
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = error => reject('Error: ', error);
+    });
+  }
+}
+
+export function renderFileSize(bytes, decimals = 2) {
+  if (!Number(bytes)) return '0 Bytes';
+
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}
+
+export function getUniqueFileExtensions(extListString) {
+  // Split the extensions list into an array
+  const extArray = extListString
+    ?.split(',')
+    .map(ext => ext.trim().toUpperCase());
+
+  // Remove duplicates using a Set
+  const uniqueExts = [...new Set(extArray)];
+
+  // Join the unique extensions into a string
+  return uniqueExts.join(', ');
+}
+
+export function getOS() {
+  const userAgent = window.navigator.userAgent;
+  const platform
+      = window.navigator?.userAgentData?.platform || window.navigator.platform;
+  const macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'];
+  const windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'];
+  const iosPlatforms = ['iPhone', 'iPad', 'iPod'];
+  let os = OS.Unknown;
+
+  if (macosPlatforms.includes(platform)) {
+    os = OS.MacOS;
+  }
+  else if (iosPlatforms.includes(platform)) {
+    os = OS.iOS;
+  }
+  else if (windowsPlatforms.includes(platform)) {
+    os = OS.Windows;
+  }
+  else if (/Android/.test(userAgent)) {
+    os = OS.Android;
+  }
+  else if (/Linux/.test(platform)) {
+    os = OS.Linux;
+  }
+
+  return os;
+}
+
+String.prototype.longerThan = function (compareWith) {
+  return this?.length > compareWith?.length;
+};
+String.prototype.lastIndexEqualsTo = function (index) {
+  return this?.length - 1 === index;
+};
+
+export function getCorrectTestId({ testId = '', withTier = true }) {
+  return testId && testId !== undefined ? `${withTier ? '-' : ''}${testId}` : ''
+}

package/dist/Molecular/CustomIcons/components/AffiliateNetworks.jsx

@@ -0,0 +1,22 @@
+export function AffiliateNetworks(props) {
+  return (
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      xmlSpace="preserve"
+      viewBox="0 0 24 24"
+      {...props}
+    >
+      <path
+        fill="none"
+        stroke="#9AA0B9"
+        d="M17 21v-2c0-2.2-1.8-4-4-4H5c-2.2 0-4 1.8-4 4v2"
+      />
+      <circle cx={9} cy={7} r={4} fill="none" stroke="#9AA0B9" />
+      <path
+        fill="none"
+        stroke="#9AA0B9"
+        d="M23 21v-2c0-1.8-1.2-3.4-3-3.9M16 3.1c2.1.5 3.4 2.7 2.9 4.9-.4 1.4-1.5 2.5-2.9 2.9"
+      />
+    </svg>
+  )
+}

package/dist/Molecular/CustomIcons/components/AlertCircle.jsx

@@ -0,0 +1,24 @@
+export function AlertCircle(props) {
+  return (
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      xmlSpace="preserve"
+      id="Layer_1"
+      x={0}
+      y={0}
+      style={{
+        enableBackground: 'new 0 0 24 24',
+      }}
+      viewBox="0 0 24 24"
+      {...props}
+    >
+      <style>
+        {
+          '.st0{fill:none;stroke:#f06d8d;strokeWidth:2;strokeLinecap:round;strokeLinejoin:round}'
+        }
+      </style>
+      <circle cx={12} cy={12} r={10} className="st0" />
+      <path d="M12 8v4M12 16" className="st0" />
+    </svg>
+  )
+}