intelicoreact 1.8.3 → 1.8.5

package/dist/Atomic/UI/WizardStepper/constructor.jsx

@@ -0,0 +1,86 @@
+import Status from '../Status/Status';
+
+export const WIZARD_STEP_VARIANTS = Object.freeze({
+  DEFAULT: 'default',
+  DONE: 'done',
+  ACTIVE: 'active',
+});
+
+function JSXMockComponent() {
+  const arr = [
+    { title: 'Requested Amont', value: '$15,000' },
+    { title: 'Repayment Amount', value: '$15,001' },
+    { title: 'Repayment Date', value: '12/12/2021' },
+  ]
+
+  const textStyles = {
+    fontSize: '14px',
+    fontWeight: 400,
+    lineHeight: '20px',
+    letterSpacing: '0.2px',
+  };
+
+  return arr.map((row) => {
+    return (
+      <div style={{ display: 'flex', justifyContent: 'space-between', maxWidth: '250px' }}>
+        <span style={textStyles}>{row.title}</span>
+        <span style={textStyles}>{row.value}</span>
+      </div>
+    )
+  });
+}
+
+export const mockData = [
+  {
+    key: 'businessInfo',
+    label: 'Provide Business Info',
+    description: 'This information will help us to evaluate your application',
+    isFinished: true,
+  },
+  {
+    key: 'principal',
+    label: 'Add Principal Information',
+    description: 'A principal is essentially another name for a company owner. At some corporations, the principal is also the founder, CEO, or even the chief investor',
+    isFinished: true,
+    isOptional: true,
+  },
+  {
+    key: 'coOwners',
+    label: 'Add Co-Owners',
+    description: '{merchantName} will receive that amount from {lenderNmae}',
+    isActive: true,
+    titleSlot: <span className="custom-title-slot">$15,001</span>,
+    contentSlot: <JSXMockComponent />,
+  },
+  {
+    key: 'bankAccount',
+    label: 'Add a Bank Account',
+    description: 'Your bank account information will be used to securely and automatically transfer the funds',
+    titleSlot: <Status label="Some JSX" status="draft" />,
+  },
+  {
+    key: 'documents',
+    label: 'Upload Documents',
+    description: 'Please upload the required documents',
+  },
+  {
+    key: 'review',
+    label: 'Review & Submit',
+    description: 'Please review the information and submit your application',
+  },
+  {
+    key: 'success',
+    label: 'Success',
+    description: 'Your application has been submitted successfully',
+  },
+  {
+    key: 'failure',
+    label: 'Failure',
+    description: 'Your application has been failed',
+  },
+  {
+    key: 'pending',
+    label: 'Pending',
+    description: 'Your application is under review',
+  },
+]

package/dist/Classes/RESTAPI/partials/CredentialsProcessing.jsx

@@ -0,0 +1,254 @@
+import outerDependencies from './_outerDependencies';
+import { getIsOnlyAnObject } from './_utils';
+
+const { jwt } = outerDependencies;
+
+class CredentialsProcessing {
+  constructor(settings) {
+    const { credentialsProcessing } = settings;
+    const {
+      // ? Для корректной работы установки токенов в запросы от API
+      // ? нужно передавать методы getCredentials и getHeadersForAuthorize
+      getCredentials,
+      getHeadersForAuthorize, // ? На вход получит токен, должна вернуть объект для коструктора Headers
+
+      // ? Так же опционально можно передавать
+      importCredentials, // ? если он передается, то он будет применяться к выводу от вызова getCredentials
+      saveCredentials, // ? можно будет найти в объекте credentialsProcessing, чтобы использовать кастомными методами
+
+      // ! Либо вызов getCredentials, либо цепочка вызовов importCredentials(getCredentials())
+      // ! должна возвращать требуемую классом структуру
+      // ! Класс требует структуры
+      // !   - { token }, если флоу рефреш токена НЕ используется
+      // !   - { token, refreshToken, expires }, если используется флоу рефреш токена
+
+      // *********
+
+      // ? Подключает флоу рефреша токенов
+      isUseRefreshTokensPropcessing = false,
+
+      // ! Для корректной работы флоу рефреша токенов передача метода saveCredentials становится ОБЯЗАТЕЛЬНОЙ
+
+      // ? Так же для корректной работы флоу рефреша токенов нужно
+      // ?   - либо
+      refreshCredentials, // ! метод должен возвращать такую же структуру как и метод getCredentials,
+      // ? на вход получит текущие креды, к выходу будет применен importCredentials, если этот метод передавался
+      // ?   - либо
+      REFRESH_TOKEN_PATH, // ! REFRESH_TOKEN_PATH передается ПОЛНОСТЬЮ (глобальная адресация)!
+      CODES_USING_THE_REFRESH_ATTEMPT, // ? указывает по каким кодам ответа триггериться рефреш, массив чисел
+
+      // ? Опционально
+      REFRESH_TOKEN_FLAG = 'refreshTokenFlag',
+      INTERVAL_FOR_CHECKING_TOKEN_UPDATE = 50, // ms
+      callbackAfterRejectRefresh,
+    } = credentialsProcessing || {};
+
+    if (typeof getCredentials !== 'function')
+      throw new Error('No getCredentials method [CredentialsProcessing]');
+    if (typeof getHeadersForAuthorize !== 'function') {
+      throw new TypeError(
+        'No getHeadersForAuthorize method [CredentialsProcessing]',
+      );
+    }
+    if (importCredentials && typeof importCredentials !== 'function') {
+      throw new Error('Bad importCredentials method [CredentialsProcessing]');
+    }
+
+    this.isUseRefreshTokensPropcessing = isUseRefreshTokensPropcessing;
+    this.DEFAULT_CREDENTIALS = {};
+    this.getCredentialsByOuter = getCredentials;
+    this.getHeadersForAuthorize = getHeadersForAuthorize;
+    this.importCredentials = importCredentials;
+
+    // ? Если метод передан или если не передан, но включен флоу обновления токенов (тогда saveCredentials обязателен)
+    if (saveCredentials || isUseRefreshTokensPropcessing) {
+      if (typeof saveCredentials !== 'function')
+        throw new Error('No saveCredentials method [CredentialsProcessing]');
+      else this.saveCredentials = saveCredentials;
+    }
+
+    if (isUseRefreshTokensPropcessing) {
+      if (typeof refreshCredentials === 'function') {
+        this.refreshCredentialsByOuter = refreshCredentials;
+      }
+      else {
+        if (
+          typeof this.refreshCredentialsByOuter === 'function'
+          && typeof REFRESH_TOKEN_PATH !== 'string'
+        ) {
+          throw new TypeError('No REFRESH_TOKEN_PATH [CredentialsProcessing]');
+        }
+        this.REFRESH_TOKEN_PATH = REFRESH_TOKEN_PATH;
+      }
+
+      if (!Array.isArray(CODES_USING_THE_REFRESH_ATTEMPT)) {
+        throw new TypeError(
+          'No CODES_USING_THE_REFRESH_ATTEMPT [CredentialsProcessing]',
+        );
+      }
+      if (
+        !CODES_USING_THE_REFRESH_ATTEMPT.every(i => typeof i === 'number')
+      ) {
+        throw new Error(
+          'Invalid format of CODES_USING_THE_REFRESH_ATTEMPT elements [CredentialsProcessing]',
+        );
+      }
+
+      if (typeof REFRESH_TOKEN_FLAG !== 'string')
+        throw new Error('Bad REFRESH_TOKEN_FLAG [CredentialsProcessing]');
+      if (typeof INTERVAL_FOR_CHECKING_TOKEN_UPDATE !== 'number') {
+        throw new TypeError(
+          'Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]',
+        );
+      }
+      if (typeof INTERVAL_FOR_CHECKING_TOKEN_UPDATE !== 'number') {
+        throw new TypeError(
+          'Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]',
+        );
+      }
+      if (
+        callbackAfterRejectRefresh
+        && typeof callbackAfterRejectRefresh !== 'function'
+      ) {
+        throw new Error(
+          'Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]',
+        );
+      }
+
+      this.CODES_USING_THE_REFRESH_ATTEMPT = CODES_USING_THE_REFRESH_ATTEMPT;
+      this.REFRESH_TOKEN_FLAG = REFRESH_TOKEN_FLAG;
+      this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE
+        = INTERVAL_FOR_CHECKING_TOKEN_UPDATE;
+
+      if (callbackAfterRejectRefresh)
+        this.callbackAfterRejectRefresh = callbackAfterRejectRefresh;
+    }
+  }
+
+  getIsTokenStartRefresh() {
+    return localStorage.getItem(this.REFRESH_TOKEN_FLAG);
+  }
+
+  setIsTokenStartRefresh() {
+    localStorage.setItem(this.REFRESH_TOKEN_FLAG, true);
+  }
+
+  removeIsTokenStartRefresh() {
+    localStorage.removeItem(this.REFRESH_TOKEN_FLAG);
+  }
+
+  async getCredentials(isCatchCallbackProcess, callback) {
+    let credentials = await this.getCredentialsByOuter();
+
+    if (typeof this.importCredentials === 'function')
+      credentials = await this.importCredentials(credentials);
+    if (!getIsOnlyAnObject(credentials)) credentials = {};
+
+    const token = credentials.token || null;
+
+    if (token && !isCatchCallbackProcess) {
+      let decoded;
+      try {
+        decoded = jwt.decode(token);
+      }
+      catch {
+        decoded = null;
+      }
+      const currentTime = Date.now() / 1000;
+      if (decoded !== null && Number(decoded.exp) < currentTime)
+        credentials = { ...credentials, isNeedRefresh: true };
+    }
+
+    if (callback) await callback({ ...credentials, isCatchCallbackProcess });
+    return { ...credentials, isCatchCallbackProcess };
+  }
+
+  async refreshCredentials(currentCredentials, callback) {
+    const CONTEXT = this;
+
+    async function finalize(cred) {
+      if (callback) await callback(cred);
+      return Promise.resolve(cred).then(async (res) => {
+        CONTEXT.removeIsTokenStartRefresh();
+        return res;
+      });
+    }
+
+    if (!currentCredentials?.token || !currentCredentials?.refreshToken)
+      return finalize(CONTEXT.DEFAULT_CREDENTIALS);
+
+    // ! ВНИМАНИЕ! Данный механизм рефреша принят на проекте finturfreactfrontend (админка)
+    // ! На кабинете он ТОЧНО НЕ ТАКОЙ
+    async function refreshCredentialsByDefault() {
+      const { token, refreshToken } = currentCredentials;
+      const headers = new Headers();
+      headers.append(...Object.entries(CONTEXT.getHeadersForAuthorize(token)));
+
+      const body = new FormData();
+      body.append('grant_type', 'refresh_token');
+      body.append('refresh_token', refreshToken);
+      body.append('client_id', 'oauth');
+      body.append('client_secret', 'secret');
+      body.append('access_type', 'offline');
+
+      return fetch(`${CONTEXT.REFRESH_TOKEN_PATH}`, {
+        mode: 'cors',
+        method: 'POST',
+        headers,
+        body,
+        redirect: 'follow',
+      });
+    }
+
+    // ? Передавайте собственный refreshCredentials при получении экземляра RESTAPI, если не уверены,
+    // ? что механизм рефреша токенов ИМЕННО ТАКОЙ как в ф-и refreshCredentialsByDefault!
+    // ! currentCredentials передаются в формате класса! ({ token, refreshToken, expires })
+    const newCredentials
+      = typeof CONTEXT.refreshCredentialsByOuter === 'function'
+        ? await CONTEXT.refreshCredentialsByOuter(currentCredentials)
+        : await refreshCredentialsByDefault();
+
+    return finalize(newCredentials);
+  }
+
+  async waitRefresh(isNeedRefresh) {
+    return new Promise((resolve) => {
+      if (!this.getIsTokenStartRefresh()) {
+        if (isNeedRefresh) this.setIsTokenStartRefresh();
+        resolve();
+      }
+      else {
+        const intervalId = setInterval(() => {
+          if (!this.getIsTokenStartRefresh()) {
+            clearInterval(intervalId);
+            resolve();
+          }
+        }, this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE);
+      }
+    });
+  }
+
+  async processCredentials(cred) {
+    if (!cred.isNeedRefresh && !cred.isCatchCallbackProcess) return cred;
+
+    const CONTEXT = this;
+
+    return CONTEXT.refreshCredentials(cred, response =>
+      CONTEXT.saveCredentials(response)).then(() => {
+      return new Promise((resolve) => {
+        setTimeout(async () => {
+          const newCredentials = await CONTEXT.getCredentials();
+          if (!newCredentials?.token) {
+            newCredentials.isRefreshFailed = true;
+            setTimeout(() => {
+              CONTEXT?.callbackAfterRejectRefresh?.();
+            }, 0);
+          }
+          resolve(newCredentials);
+        }, 0);
+      });
+    });
+  }
+}
+
+export default CredentialsProcessing;

package/dist/Functions/customEventListener.jsx

@@ -0,0 +1,96 @@
+(function () {
+  Element.prototype._addEventListener = Element.prototype.addEventListener;
+  Element.prototype.addEventListener = function (a, b, c) {
+    if (c == undefined) c = false;
+    this._addEventListener(a, b, c);
+    if (!this.eventListenerList) this.eventListenerList = {};
+    if (!this.eventListenerList[a]) this.eventListenerList[a] = [];
+    // this.removeEventListener(a,b,c); // TODO - handle duplicates..
+    this.eventListenerList[a].push({ listener: b, useCapture: c });
+  };
+
+  Element.prototype.getEventListeners = function (a) {
+    if (!this.eventListenerList) this.eventListenerList = {};
+    if (a == undefined) return this.eventListenerList;
+    return this.eventListenerList[a];
+  };
+  Element.prototype.clearEventListeners = function (a) {
+    if (!this.eventListenerList) this.eventListenerList = {};
+    if (a == undefined) {
+      for (const x in this.getEventListeners()) this.clearEventListeners(x);
+      return;
+    }
+    const el = this.getEventListeners(a);
+    if (el == undefined) return;
+    for (let i = el.length - 1; i >= 0; --i) {
+      const ev = el[i];
+      this.removeEventListener(a, ev.listener, ev.useCapture);
+    }
+  };
+
+  Element.prototype._removeEventListener
+    = Element.prototype.removeEventListener;
+  Element.prototype.removeEventListener = function (a, b, c) {
+    if (c == undefined) c = false;
+    this._removeEventListener(a, b, c);
+    if (!this.eventListenerList) this.eventListenerList = {};
+    if (!this.eventListenerList[a]) this.eventListenerList[a] = [];
+
+    // Find the event in the list
+    for (let i = 0; i < this.eventListenerList[a].length; i++) {
+      if (
+        (this.eventListenerList[a][i].listener == b,
+        this.eventListenerList[a][i].useCapture == c)
+      ) {
+        // Hmm..
+        this.eventListenerList[a].splice(i, 1);
+        break;
+      }
+    }
+    if (this.eventListenerList[a].length == 0) delete this.eventListenerList[a];
+  };
+})();
+
+/**
+ * Добавляет обработчик события к элементу
+ * @param {HTMLElement} element - DOM элемент
+ * @param {string} eventName - Название события
+ * @param {Function} handler - Функция-обработчик
+ */
+export function addEventListener(element, eventName, handler) {
+  if (element && element.addEventListener) {
+    element.addEventListener(eventName, handler);
+  }
+}
+
+/**
+ * Удаляет обработчик события с элемента
+ * @param {HTMLElement} element - DOM элемент
+ * @param {string} eventName - Название события
+ * @param {Function} handler - Функция-обработчик
+ */
+export function removeEventListener(element, eventName, handler) {
+  if (element && element.removeEventListener) {
+    element.removeEventListener(eventName, handler);
+  }
+}
+
+/**
+ * Создает и отправляет кастомное событие
+ * @param {HTMLElement} element - DOM элемент
+ * @param {string} eventName - Название события
+ * @param {object} detail - Данные события
+ */
+export function dispatchCustomEvent(element, eventName, detail = {}) {
+  if (element) {
+    const event = new CustomEvent(eventName, { detail });
+    element.dispatchEvent(event);
+  }
+}
+
+// Экспортируем объект со всеми функциями для обратной совместимости
+export default {
+  addEventListener,
+  removeEventListener,
+  dispatchCustomEvent,
+};

package/dist/Functions/operations.jsx

@@ -0,0 +1,138 @@
+// Взято из https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math/round
+// При импорте любой ф-и из этого файла отработает самовызывающаяся ф-я и расширит
+// объект Math 3-мя ф-ми: round10, floor10, ceil10
+(function () {
+  /**
+   * Корректировка округления десятичных дробей.
+   *
+   * @param {string}  type  Тип корректировки.
+   * @param {number}  value Число.
+   * @param {Integer} exp   Показатель степени (десятичный логарифм основания корректировки).
+   * @returns {number} Скорректированное значение.
+   */
+  function decimalAdjust(type, value, exp) {
+    // Если степень не определена, либо равна нулю...
+    if (typeof exp === 'undefined' || Number(exp) === 0) {
+      return Math[type](value);
+    }
+    value = Number(value);
+    exp = Number(exp);
+    // Если значение не является числом, либо степень не является целым числом...
+    if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
+      return Number.NaN;
+    }
+    // Сдвиг разрядов
+    value = value.toString().split('e');
+    value = Math[type](
+      Number(`${value[0]}e${value[1] ? Number(value[1]) - exp : -exp}`),
+    );
+    // Обратный сдвиг
+    value = value.toString().split('e');
+    return Number(`${value[0]}e${value[1] ? Number(value[1]) + exp : exp}`);
+  }
+
+  // Десятичное округление к ближайшему
+  if (!Math.round10) {
+    Math.round10 = function (value, exp) {
+      return decimalAdjust('round', value, exp);
+    };
+  }
+  // Десятичное округление вниз
+  if (!Math.floor10) {
+    Math.floor10 = function (value, exp) {
+      return decimalAdjust('floor', value, exp);
+    };
+  }
+  // Десятичное округление вверх
+  if (!Math.ceil10) {
+    Math.ceil10 = function (value, exp) {
+      return decimalAdjust('ceil', value, exp);
+    };
+  }
+})();
+
+export function addRangeDefault(from, to, currentValues, decimalPlaces) {
+  if (!currentValues?.length) return [{ from, to }];
+  const step = decimalPlaces ? 10 ** (-1 * decimalPlaces) : 1;
+
+  const resultOfProcessAddingRange = currentValues.reduce(
+    (acc, range) => {
+      const isIncludesFrom
+        = Boolean(acc.from) && range.from < acc.from && range.to >= acc.from;
+      const isIncludesTo
+        = Boolean(acc.to) && range.from <= acc.to && range.to > acc.to;
+      const isRangeMustBeIncludet
+        = Boolean(acc.from)
+          && Boolean(acc.to)
+          && acc.from <= range.from
+          && acc.to >= range.to;
+
+      const processTo = () => {
+        const lastAccRange = acc.result[acc.result.length - 1];
+
+        if (acc.to < range.from) {
+          lastAccRange.to = acc.to;
+          acc.to = null;
+          acc.result = [...acc.result, range];
+        }
+        else if (isIncludesTo) {
+          lastAccRange.to = acc.to;
+          acc.result = [
+            ...acc.result,
+            {
+              from: Math.round10(acc.to + step, -1 * decimalPlaces),
+              to: range.to,
+            },
+          ];
+          acc.to = null;
+        }
+        else if (acc.to === range.to) {
+          lastAccRange.to = acc.to;
+          acc.to = null;
+        }
+      };
+
+      if (!acc.from && !acc.to) {
+        acc.result = [...acc.result, range];
+      }
+      else if (!acc.from && acc.to) {
+        processTo();
+      }
+      else if (acc.from && acc.to) {
+        if (acc.from <= range.from) {
+          acc.result = [...acc.result, { from: acc.from }];
+          acc.from = null;
+          processTo();
+        }
+        else if (isIncludesFrom) {
+          acc.result = [
+            ...acc.result,
+            {
+              from: range.from,
+              to: Math.round10(acc.from - step, -1 * decimalPlaces),
+            },
+            { from: acc.from },
+          ];
+          acc.from = null;
+          processTo();
+        }
+        else {
+          acc.result = [
+            ...acc.result,
+            ...(!isRangeMustBeIncludet ? [range] : []),
+            {
+              from: Math.round10(acc.from, -1 * decimalPlaces),
+              to: Math.round10(acc.to, -1 * decimalPlaces),
+            },
+          ];
+        }
+      }
+      return acc;
+    },
+    { from, to, result: [] },
+  );
+
+  const result = resultOfProcessAddingRange.result;
+  if (!result[result.length - 1].to) result[result.length - 1].to = to;
+  return result;
+}

package/dist/Functions/useFormTools/functions/RenderFields.jsx

@@ -0,0 +1,108 @@
+function defaultRenderFieldComponent() {
+  console.error('RenderFields: RenderFieldComponent Property is not recieved!');
+  return null;
+}
+
+function defaultFormDataDriver() {
+  console.error('RenderFields: FormDataDriver Property is not recieved!');
+  return null;
+}
+
+function defaultOnFieldChange() {
+  console.warn(
+    'RenderFields: Be careful, onFieldChange handler is not recieved!',
+  );
+  return null;
+}
+
+function defaultOnFieldBlur() {
+  console.warn(
+    'RenderFields: Be careful, defaultOnFieldBlur handler is not recieved!',
+  );
+  return null;
+}
+
+export default function RenderFields({
+  form,
+  fields,
+  cols = 1,
+  FormDataDriver = defaultFormDataDriver,
+  RenderFieldComponent = defaultRenderFieldComponent,
+  onFieldChange = defaultOnFieldChange,
+  onFieldBlur = defaultOnFieldBlur,
+} = {}) {
+  const maxColumns = 6;
+  const maxWidth = 12;
+
+  const { getFormField } = FormDataDriver({ form });
+
+  const getColumnsQty = () => {
+    return cols > maxColumns ? maxColumns : cols;
+  };
+
+  const renderFormField = (key) => {
+    try {
+      const field = { ...getFormField(key), key };
+      const { wrapperRef } = field;
+
+      return (
+        <div
+          key={`render-field-wrapper-${key}`}
+          id={`render-field-wrapper-${key}`}
+          ref={
+            wrapperRef
+              ? typeof wrapperRef === 'function'
+                ? node => wrapperRef(node, key)
+                : wrapperRef
+              : null
+          }
+        >
+          <RenderFieldComponent
+            key={key}
+            field={field}
+            onChange={value => onFieldChange(key, value)}
+            onBlur={(...args) => onFieldBlur(...args)}
+          />
+        </div>
+      );
+    }
+    catch (e) {
+      return null;
+    }
+  };
+
+  const renderSingleColumn = () => {
+    return fields.map(renderFormField);
+  };
+  const renderSplitColumns = () => {
+    const fieldsLen = fields?.length || 0;
+    const columnsQty
+      = getColumnsQty() > fieldsLen ? fieldsLen : getColumnsQty();
+
+    if (!columnsQty) return null;
+
+    const parts = new Array(columnsQty).fill([]).map((v, i) => {
+      const startIndex = (fieldsLen / columnsQty) * i;
+      const endIndex = startIndex + fieldsLen / columnsQty;
+
+      return fields.slice(startIndex, endIndex);
+    });
+
+    return (
+      <div className="row">
+        {parts.map((part, i) => (
+          <div
+            key={`render-fields-row-${i}`}
+            className={`col-12 col-lg-${Number.parseInt(maxWidth / columnsQty, 10)}`}
+          >
+            {part.map(renderFormField)}
+          </div>
+        ))}
+      </div>
+    );
+  };
+
+  const render = cols === 1 ? renderSingleColumn : renderSplitColumns;
+
+  return render();
+}