intelicoreact 1.6.1 → 1.6.3

package/dist/Atomic/UI/PieChart/PieChart.stories.js

@@ -17,6 +17,7 @@ _export(exports, {
     }
 });
 const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
 const _PieChart = /*#__PURE__*/ _interop_require_default(require("./PieChart"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -26,57 +27,58 @@ function _interop_require_default(obj) {
 const _default = {
     title: 'UI/PieChart',
     component: _PieChart.default,
-    argTypes: {},
-    args: {
-        cutout: '85%',
-        withLegend: false,
-        resultLabel: 'Conversion rate',
-        resultValue: 85.12,
-        data: {
-            labels: [
-                'Red',
-                'Blue',
-                'Yellow',
-                'Green',
-                'Purple',
-                'Orange'
-            ],
-            datasets: [
-                {
-                    label: '# of Votes',
-                    data: [
-                        12,
-                        19,
-                        3,
-                        5,
-                        2,
-                        3
-                    ],
-                    backgroundColor: [
-                        'rgba(255, 99, 132, 0.2)',
-                        'rgba(54, 162, 235, 0.2)',
-                        'rgba(255, 206, 86, 0.2)',
-                        'rgba(75, 192, 192, 0.2)',
-                        'rgba(153, 102, 255, 0.2)',
-                        'rgba(255, 159, 64, 0.2)'
-                    ],
-                    borderColor: [
-                        'rgba(255, 99, 132, 1)',
-                        'rgba(54, 162, 235, 1)',
-                        'rgba(255, 206, 86, 1)',
-                        'rgba(75, 192, 192, 1)',
-                        'rgba(153, 102, 255, 1)',
-                        'rgba(255, 159, 64, 1)'
-                    ],
-                    borderWidth: 0
-                }
-            ]
-        }
-    }
+    argTypes: {}
 };
-function Template(args) {
+const Template = (args)=>{
+    const data = {
+        labels: [
+            'Red',
+            'Blue',
+            'Yellow',
+            'Green',
+            'Purple',
+            'Orange'
+        ],
+        datasets: [
+            {
+                label: '# of Votes',
+                data: [
+                    12,
+                    19,
+                    3,
+                    5,
+                    2,
+                    3
+                ],
+                backgroundColor: [
+                    'rgba(255, 99, 132, 0.2)',
+                    'rgba(54, 162, 235, 0.2)',
+                    'rgba(255, 206, 86, 0.2)',
+                    'rgba(75, 192, 192, 0.2)',
+                    'rgba(153, 102, 255, 0.2)',
+                    'rgba(255, 159, 64, 0.2)'
+                ],
+                borderColor: [
+                    'rgba(255, 99, 132, 1)',
+                    'rgba(54, 162, 235, 1)',
+                    'rgba(255, 206, 86, 1)',
+                    'rgba(75, 192, 192, 1)',
+                    'rgba(153, 102, 255, 1)',
+                    'rgba(255, 159, 64, 1)'
+                ],
+                borderWidth: 0
+            }
+        ]
+    };
     return /*#__PURE__*/ (0, _jsxruntime.jsx)(_PieChart.default, {
-        ...args
+        ...args,
+        data: data
     });
-}
+};
 const ChartTemplate = Template.bind({});
+ChartTemplate.args = {
+    cutout: '85%',
+    withLegend: false,
+    resultLabel: 'Conversion rate',
+    resultValue: 85.12
+};

package/dist/DeepPartial.d.ts

@@ -0,0 +1,40 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Рекурсивный утилитарный тип, который делает все свойства объекта и его вложенных объектов опциональными.
+ *
+ * @template T - Тип данных для преобразования
+ *
+ * @description
+ * Если T является объектом, рекурсивно применяет DeepPartial к каждому свойству объекта.
+ * Если T является массивом, применяет DeepPartial к типу элементов массива.
+ * Если T не является объектом или массивом, возвращает исходный тип без изменений.
+ *
+ * @example
+ * interface User {
+ *   name: string;
+ *   age: number;
+ *   settings: {
+ *     theme: string;
+ *     notifications: boolean;
+ *   };
+ *   roles: string[];
+ * }
+ *
+ * type PartialUser = DeepPartial<User>;
+ *  Результат:
+ *  {
+ *    name?: string;
+ *    age?: number;
+ *    settings?: {
+ *      theme?: string;
+ *      notifications?: boolean;
+ *    };
+ *    roles?: string[];
+ *  }
+ */
+export type DeepPartial<T> = PrettyPrint<T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends object
+    ? { [K in keyof T]?: DeepPartial<T[K]> }
+    : T>

package/dist/DeepReadonly.d.ts

@@ -0,0 +1,38 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Рекурсивный утилитарный тип, который делает все свойства объекта и его вложенных объектов доступными только для чтения.
+ *
+ * @template T - Тип данных для преобразования
+ *
+ * @description
+ * Если T является объектом, рекурсивно применяет DeepReadonly к каждому свойству объекта.
+ * Если T является массивом, применяет DeepReadonly к типу элементов массива и делает сам массив readonly.
+ * Если T не является объектом или массивом, возвращает исходный тип без изменений.
+ *
+ * @example
+ * interface Config {
+ *   apiKey: string;
+ *   endpoints: {
+ *     base: string;
+ *     auth: string;
+ *   };
+ *   timeouts: number[];
+ * }
+ *
+ * type ReadonlyConfig = DeepReadonly<Config>;
+ *  Результат:
+ *  {
+ *    readonly apiKey: string;
+ *    readonly endpoints: {
+ *      readonly base: string;
+ *      readonly auth: string;
+ *    };
+ *    readonly timeouts: readonly number[];
+ *  }
+ */
+export type DeepReadonly<T> = PrettyPrint<T extends Array<infer U>
+  ? ReadonlyArray<DeepReadonly<U>>
+  : T extends object
+    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
+    : T>

package/dist/DeepRequired.d.ts

@@ -0,0 +1,50 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Рекурсивный утилитарный тип, который делает все свойства объекта и его вложенных объектов обязательными.
+ *
+ * @template T - Тип данных для преобразования
+ *
+ * @description
+ * Если T является объектом, рекурсивно применяет DeepRequired к каждому свойству объекта.
+ * Если T является массивом, применяет DeepRequired к типу элементов массива.
+ * Если T не является объектом или массивом, возвращает исходный тип без изменений.
+ *
+ * @example
+ * interface Settings {
+ *   theme?: {
+ *     primary?: string;
+ *     secondary?: string;
+ *   };
+ *   features?: {
+ *     darkMode?: boolean;
+ *     notifications?: {
+ *       email?: boolean;
+ *       push?: boolean;
+ *     };
+ *   };
+ *   tags?: string[];
+ * }
+ *
+ * type RequiredSettings = DeepRequired<Settings>;
+ *  Результат:
+ *  {
+ *    theme: {
+ *      primary: string;
+ *      secondary: string;
+ *    };
+ *    features: {
+ *      darkMode: boolean;
+ *      notifications: {
+ *        email: boolean;
+ *        push: boolean;
+ *      };
+ *    };
+ *    tags: string[];
+ *  }
+ */
+export type DeepRequired<T> = PrettyPrint<T extends Array<infer U>
+  ? Array<DeepRequired<U>>
+  : T extends object
+    ? { [K in keyof T]-?: DeepRequired<T[K]> }
+    : T>

package/dist/Flatten.d.ts

@@ -0,0 +1,34 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Утилитарный тип для преобразования многомерного массива в одномерный.
+ *
+ * @template T - Тип элементов массива
+ *
+ * @description
+ * Рекурсивно преобразует вложенные массивы в плоский массив.
+ * Работает с массивами любой вложенности.
+ * Сохраняет типы элементов при преобразовании.
+ *
+ * @example
+ * Простой двумерный массив
+ * type Matrix = number[][];
+ * type FlatMatrix = Flatten<Matrix>; // number[]
+ *
+ * Массив смешанных типов
+ * type MixedArray = [string, [number, [boolean]]];
+ * type FlatMixed = Flatten<MixedArray>; // (string | number | boolean)[]
+ *
+ * Глубоко вложенный массив
+ * type DeepArray = [1, [2, [3, [4, [5]]]]];
+ * type FlatDeep = Flatten<DeepArray>; // [1, 2, 3, 4, 5]
+ *
+ * Использование с пустыми массивами
+ * type EmptyArray = [];
+ * type FlatEmpty = Flatten<EmptyArray>; // []
+ */
+export type Flatten<T> = PrettyPrint<T extends Array<infer U>
+  ? U extends Array<any>
+    ? Flatten<U>
+    : U
+  : never>

package/dist/FunctionType.d.ts

@@ -0,0 +1,37 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Утилитарный тип для типизации функций с различными параметрами и возвращаемыми значениями.
+ *
+ * @template P - Тип параметров функции (кортеж)
+ * @template R - Тип возвращаемого значения
+ *
+ * @description
+ * Позволяет создавать типы функций с заданными параметрами и возвращаемым значением.
+ * Поддерживает как синхронные, так и асинхронные функции.
+ * Может использоваться для типизации коллбэков и функциональных параметров.
+ *
+ * @example
+ * Простая функция с одним параметром
+ * type StringToNumber = FunctionType<[string], number>;
+ * (arg: string) => number
+ *
+ * Функция с несколькими параметрами
+ * type Calculator = FunctionType<[number, number, string], number>;
+ * (a: number, b: number, operation: string) => number
+ *
+ * Функция без параметров
+ * type Generator = FunctionType<[], string>;
+ * () => string
+ *
+ * Асинхронная функция
+ * type AsyncOperation = FunctionType<[number], Promise<string>>;
+ * (id: number) => Promise<string>
+ *
+ * Использование в интерфейсе
+ * interface EventHandler {
+ *   onClick: FunctionType<[Event], void>;
+ *   onSubmit: FunctionType<[FormData], Promise<void>>;
+ * }
+ */
+export type FunctionType<P extends any[] = any[], R = any> = PrettyPrint<(...args: P) => R>

package/dist/If.d.ts

@@ -0,0 +1,34 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Утилитарный тип для условного ветвления на уровне типов.
+ *
+ * @template C - Условие (должно быть boolean)
+ * @template T - Тип, возвращаемый при истинном условии
+ * @template F - Тип, возвращаемый при ложном условии
+ *
+ * @description
+ * Позволяет выбирать между двумя типами на основе условия.
+ * Работает аналогично тернарному оператору в JavaScript.
+ * Может использоваться в сложных типовых конструкциях для создания условной логики.
+ *
+ * @example
+ * Простое условие
+ * type IsString<T> = T extends string ? true : false;
+ * type Result = If<IsString<"text">, number, string>; // number
+ *
+ * Проверка пустого объекта
+ * type IsEmpty<T> = T extends {} ? keyof T extends never ? true : false : false;
+ * type EmptyCheck = If<IsEmpty<{}>, "Empty", "Not Empty">; // "Empty"
+ *
+ * Условная типизация в интерфейсах
+ * interface Config<T> {
+ *   value: If<T extends number, "numeric", "non-numeric">;
+ *   data: If<T extends string, string[], number[]>;
+ * }
+ *
+ * Использование с дженериками
+ * type ArrayType<T> = If<T extends any[], T[number], T>;
+ * type ElementType = ArrayType<string[]>; // string
+ */
+export type If<C extends boolean, T, F> = PrettyPrint<C extends true ? T : F>

package/dist/KeysType.d.ts

@@ -0,0 +1,10 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Извлекает все ключи объекта T в виде union типа.
+ * @template T - Тип объекта, из которого извлекаются ключи
+ * @example
+ * type Person = { name: string; age: number }
+ * type PersonKeys = KeysType<Person> // "name" | "age"
+ */
+export type KeysType<T> = PrettyPrint<keyof T>

package/dist/Langs.d.ts

@@ -0,0 +1,179 @@
+export default Langs;
+declare namespace Langs {
+    namespace en {
+        let auth: {};
+        let settings: {};
+        namespace labels {
+            let industries: string;
+            let includedLenders: string;
+            let admin: string;
+            let user: string;
+            let help: string;
+            let description: string;
+            let value: string;
+            let paramName: string;
+            let active: string;
+            let pause: string;
+            let error: string;
+            let sold: string;
+            let processing: string;
+            let home: string;
+            let goods: string;
+            let improvement: string;
+            let jewelry: string;
+            let firstName: string;
+            let lastName: string;
+            let dateOfBirth: string;
+            let militaryStatus: string;
+            let ssn: string;
+            let lengthAtAddress: string;
+            let rentOrOwn: string;
+            let zip: string;
+            let city: string;
+            let state: string;
+            let address: string;
+            let email: string;
+            let homePhone: string;
+            let cellPhone: string;
+            let contactTime: string;
+            let dlState: string;
+            let dlNumber: string;
+            let ownCar: string;
+            let tcpaOptin: string;
+            let incomeSource: string;
+            let timeEmployed: string;
+            let jobTitle: string;
+            let currentEmployer: string;
+            let employersPhone: string;
+            let netMonthlyIncome: string;
+            let howOftenIsPaid: string;
+            let nextPayDate: string;
+            let secondPayDate: string;
+            let loanAmount: string;
+            let ip: string;
+            let storyName: string;
+            let channelName: string;
+            let employmentInfo: string;
+            let personalDetails: string;
+            let offer: string;
+            let offers: string;
+            let status: string;
+            let name: string;
+            let from: string;
+            let to: string;
+            let periodMonths: string;
+            let loansSent: string;
+            let approved: string;
+            let rejected: string;
+            let loanAmountApproved: string;
+            let loanAmountRejected: string;
+            let approveRate: string;
+            let actions: string;
+            let locations: string;
+            let score: string;
+            let priority: string;
+            let lender: string;
+            let weight: string;
+            let selectLender: string;
+        }
+        let singulars: {};
+        namespace titles {
+            export let pingTree: string;
+            export let edit: string;
+            export let create: string;
+            export let add: string;
+            export let consumerInfo: string;
+            let personalDetails_1: string;
+            export { personalDetails_1 as personalDetails };
+            let employmentInfo_1: string;
+            export { employmentInfo_1 as employmentInfo };
+            export let tools: string;
+            export let lenders: string;
+            let settings_1: string;
+            export { settings_1 as settings };
+            export let dashboard: string;
+            export let consumers: string;
+            export let ticketDesk: string;
+            export let accounting: string;
+            export let users: string;
+            export let merchants: string;
+            export let lenderPingTree: string;
+            export let reports: string;
+            export let leads: string;
+            export let location: string;
+            export let mainMenu: string;
+            export let partners: string;
+            export let other: string;
+            export let homeGoodsAndInteriorDesign: string;
+        }
+        namespace placeholders {
+            export let typeName: string;
+            export let params: string;
+            let value_1: string;
+            export { value_1 as value };
+            let description_1: string;
+            export { description_1 as description };
+        }
+        namespace hints {
+            let landerNotIncluded: string;
+            let noMerchants: string;
+        }
+        namespace buttons {
+            let create_1: string;
+            export { create_1 as create };
+            let edit_1: string;
+            export { edit_1 as edit };
+            let add_1: string;
+            export { add_1 as add };
+            export let close: string;
+            export let apply: string;
+            let pingTree_1: string;
+            export { pingTree_1 as pingTree };
+            export let addRow: string;
+            let consumerInfo_1: string;
+            export { consumerInfo_1 as consumerInfo };
+            export let deletePingTree: string;
+            export let cancel: string;
+        }
+        let radioButtons: {};
+        namespace weekDays {
+            let su: string;
+            let mo: string;
+            let tu: string;
+            let we: string;
+            let th: string;
+            let fr: string;
+            let sa: string;
+        }
+        namespace alerts {
+            let lendersWillBeRemoved: string;
+        }
+        namespace checkboxes {
+            export let homeGoods: string;
+            export let travel: string;
+            export let energyImprovement: string;
+            export let jewelryIncluded: string;
+            let jewelry_1: string;
+            export { jewelry_1 as jewelry };
+            export let autoRepair: string;
+            export let cosmetics: string;
+            export let health: string;
+        }
+        let errors: {};
+        let texts: {};
+        namespace tabs {
+            export let general: string;
+            export let payments: string;
+            export let filters: string;
+            let offers_1: string;
+            export { offers_1 as offers };
+            let merchants_1: string;
+            export { merchants_1 as merchants };
+            export let integration: string;
+            export let customDetails: string;
+            export let customerDetails: string;
+            export let postsLog: string;
+        }
+        let toasts: {};
+    }
+}

package/dist/NonNullableType.d.ts

@@ -0,0 +1,13 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Создает тип, исключающий null и undefined из типа T.
+ * @template T - Исходный тип
+ * @example
+ * type MaybeString = string | null | undefined
+ * type DefinitelyString = NonNullableType<MaybeString> // string
+ *
+ * type MaybeNumber = number | null
+ * type DefinitelyNumber = NonNullableType<MaybeNumber> // number
+ */
+export type NonNullableType<T> = PrettyPrint<T extends null | undefined ? never : T>

package/dist/ObjectType.d.ts

@@ -0,0 +1,9 @@
+import type { PrettyPrint } from './PrettyPrint'
+
+/**
+ * Создает тип объекта со строковыми ключами и значениями типа T.
+ * @template T - Тип значений объекта
+ * @example
+ * type StringDict = ObjectType<string> // { [key: string]: string }
+ */
+export type ObjectType<T = unknown> = PrettyPrint<Record<string, T>>

package/dist/OnlyObjectKeys.d.ts

@@ -0,0 +1,65 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Namespace TOnlyObjectKeys предоставляет набор утилитарных типов для извлечения ключей объекта
+ * на основе типа их значений. Это полезно когда нужно получить только те ключи объекта,
+ * значения которых соответствуют определенному типу.
+ *
+ * Как это работает:
+ * 1. Используется mapped type [K in keyof T] для итерации по всем ключам объекта
+ * 2. Условный тип T[K] extends TargetType проверяет тип значения каждого ключа
+ * 3. Если условие истинно, возвращается K (ключ), иначе never
+ * 4. [keyof T] в конце извлекает объединение всех ключей, кроме never
+ *
+ * Пример использования:
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   isActive: boolean;
+ *   tags: string[];
+ *   settings: object;
+ * }
+ *
+ * type StringKeys = TOnlyObjectKeys.String<User>; // "name"
+ * type NumberKeys = TOnlyObjectKeys.Number<User>; // "id"
+ * type BooleanKeys = TOnlyObjectKeys.Boolean<User>; // "isActive"
+ * type ArrayKeys = TOnlyObjectKeys.Array<User>; // "tags"
+ * type ObjectKeys = TOnlyObjectKeys.Object<User>; // "settings"
+ */
+export namespace OnlyObjectKeys {
+  export type String<T> = PrettyPrint<{
+    [K in keyof T]: T[K] extends string ? K : never;
+  }[keyof T]>
+
+  export type Number<T> = PrettyPrint<{
+    [K in keyof T]: T[K] extends number ? K : never;
+  }[keyof T]>
+
+  export type Boolean<T> = PrettyPrint<{
+    [K in keyof T]: T[K] extends boolean ? K : never;
+  }[keyof T]>
+
+  export type Object<T> = PrettyPrint<{
+    [K in keyof T]: T[K] extends object ? K : never;
+  }[keyof T]>
+
+  export type Array<T> = {
+    [K in keyof T]: T[K] extends Array<any> ? K : never;
+  }[keyof T];
+
+  export type StringArray<T> = PrettyPrint<{
+    [K in keyof T]: T[K] extends Array<string> ? K : never;
+  }[keyof T]>
+
+  export type NumberArray<T> = PrettyPrint<{
+    [K in keyof T]: T[K] extends Array<number> ? K : never;
+  }[keyof T]>
+
+  export type BooleanArray<T> = PrettyPrint<{
+    [K in keyof T]: T[K] extends Array<boolean> ? K : never;
+  }[keyof T]>
+
+  export type PrObjectArray<T> = PrettyPrint<{
+    [K in keyof T]: T[K] extends Array<object> ? K : never;
+  }[keyof T]>
+}

package/dist/{types/declaration/PrettyPrint.d.js → PrettyPrint.d.ts}

@@ -25,7 +25,5 @@
  *      notifications: boolean;
  *    };
  *  }
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
+ */
+export type PrettyPrint<T> = T extends object ? { [K in keyof T]: PrettyPrint<T[K]> } : T

package/dist/RequiredFields.d.ts

@@ -0,0 +1,21 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Создает тип, делающий указанные поля объекта обязательными, оставляя остальные без изменений.
+ * @template T - Исходный тип объекта
+ * @template K - Union тип ключей, которые должны стать обязательными
+ * @example
+ * interface User {
+ *   name?: string;
+ *   email?: string;
+ *   age?: number;
+ * }
+ *
+ * type UserWithRequiredContact = RequiredFields<User, 'name' | 'email'>
+ *  {
+ *    name: string;
+ *    email: string;
+ *    age?: number;
+ *  }
+ */
+export type RequiredFields<T, K extends keyof T> = PrettyPrint<T & Required<Pick<T, K>>>

package/dist/TupleType.d.ts

@@ -0,0 +1,10 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Создает тип кортежа (tuple) из двух типов.
+ * @template T1 - Тип первого элемента кортежа
+ * @template T2 - Тип второго элемента кортежа
+ * @example
+ * type Coordinates = TupleType<number, number> // [number, number]
+ */
+export type TupleType<T1, T2> = PrettyPrint<[T1, T2]>