intelicoreact 1.6.8 → 1.6.11

package/dist/{_vars.scss → scss/_vars.scss}

@@ -61,3 +61,44 @@ $h4-lh: 1.18;
 
 $txt: 14px;
 $txt--lh: math.div(20, 14);
+
+// Экспортируем все переменные и миксины для использования в других проектах
+
+// Цвета
+$primary-color: #3f51b5;
+$secondary-color: #f50057;
+$success-color: #4caf50;
+$warning-color: #ff9800;
+$error-color: #f44336;
+$info-color: #2196f3;
+$background-color: #ffffff;
+$text-color: #212121;
+$text-secondary-color: #757575;
+
+// Отступы
+$spacing-xs: 4px;
+$spacing-sm: 8px;
+$spacing-md: 16px;
+$spacing-lg: 24px;
+$spacing-xl: 32px;
+
+// Шрифты
+$font-family: "Roboto", sans-serif;
+$font-size-xs: 12px;
+$font-size-sm: 14px;
+$font-size-md: 16px;
+$font-size-lg: 18px;
+$font-size-xl: 20px;
+
+// Экспортируем переменные для использования вне этого файла
+:export {
+  primaryColor: $primary-color;
+  secondaryColor: $secondary-color;
+  successColor: $success-color;
+  warningColor: $warning-color;
+  errorColor: $error-color;
+  infoColor: $info-color;
+  backgroundColor: $background-color;
+  textColor: $text-color;
+  textSecondaryColor: $text-secondary-color;
+}

package/dist/scss/index.scss

@@ -0,0 +1,4 @@
+@forward "./vars";
+@forward "./mixins";
+@forward "./fonts";
+@forward "./main";

package/dist/{main.scss → scss/main.scss}

@@ -1,7 +1,15 @@
 @use "sass:meta";
 @use "./fonts";
-@use "~anme/scss/anme-vars";
-@use "~anme/scss/styles.scss";
+@use "./vars";
+@use "./mixins";
+
+// Если нужно использовать anme, используем через переменную для возможности переопределения
+$use-anme: true !default;
+
+@if $use-anme {
+  @use "anme/scss/anme-vars";
+  @use "anme/scss/styles.scss";
+}
 
 body {
   margin: 0;

package/dist/types/base.interface.ts

@@ -0,0 +1,7 @@
+export interface IUniProps {
+  /** Additional CSS class names */
+  className?: string;
+
+  /** Test ID for testing purposes */
+  testId?: string;
+}

package/dist/types/base.types.ts

@@ -0,0 +1,7 @@
+export type HTMLElementOrAnchor = HTMLElement | HTMLAnchorElement;
+
+export type RefType<T extends HTMLElementOrAnchor = HTMLElement> =
+  | React.RefObject<T>
+  | ((node: T) => void)
+  | null
+  | undefined;

package/dist/types/declaration/ArrayElement.d.ts

@@ -0,0 +1,13 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Извлекает тип элементов массива.
+ * @template T - Тип массива
+ * @example
+ * type Numbers = number[]
+ * type NumberType = ArrayElement<Numbers> // number
+ *
+ * type MixedArray = (string | number)[]
+ * type ElementType = ArrayElement<MixedArray> // string | number
+ */
+export type ArrayElement<T> = PrettyPrint<T extends (infer U)[] ? U : never>

package/dist/types/declaration/AsyncReturnType.d.ts

@@ -0,0 +1,17 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Извлекает тип значения, возвращаемого асинхронной функцией.
+ * @template T - Тип асинхронной функции
+ * @example
+ * async function fetchUser() {
+ *   return { id: 1, name: 'John' }
+ * }
+ *
+ * type User = AsyncReturnType<typeof fetchUser>
+ *  { id: number; name: string }
+ *
+ * type Response = AsyncReturnType<() => Promise<string>>
+ * string
+ */
+export type AsyncReturnType<T extends (...args: any) => Promise<any>> = PrettyPrint<T extends (...args: any) => Promise<infer R> ? R : never>

package/dist/types/declaration/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/types/declaration/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/types/declaration/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/types/declaration/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/types/declaration/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/types/declaration/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/types/declaration/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/types/declaration/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/types/declaration/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/types/declaration/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.js → PrettyPrint.d.ts}

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

package/dist/types/declaration/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/types/declaration/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]>

package/dist/types/declaration/ValuesType.d.ts

@@ -0,0 +1,10 @@
+import type { PrettyPrint } from './PrettyPrint';
+
+/**
+ * Извлекает тип всех возможных значений объекта T.
+ * @template T - Тип объекта, из которого извлекаются значения
+ * @example
+ * type Person = { name: string; age: number }
+ * type PersonValues = ValuesType<Person> // string | number
+ */
+export type ValuesType<T> = PrettyPrint<T[keyof T]>

package/dist/types/declaration/index.ts

@@ -0,0 +1,35 @@
+import type { ArrayElement } from './ArrayElement.d';
+import type { AsyncReturnType } from './AsyncReturnType.d';
+import type { DeepPartial } from './DeepPartial.d';
+import type { DeepReadonly } from './DeepReadonly.d';
+import type { DeepRequired } from './DeepRequired.d';
+import type { Flatten } from './Flatten.d';
+import type { FunctionType } from './FunctionType.d';
+import type { If } from './If.d';
+import type { KeysType } from './KeysType.d';
+import type { NonNullableType } from './NonNullableType.d';
+import type { ObjectType } from './ObjectType.d';
+import type { OnlyObjectKeys } from './OnlyObjectKeys.d';
+import type { PrettyPrint } from './PrettyPrint.d';
+import type { RequiredFields } from './RequiredFields.d';
+import type { TupleType } from './TupleType.d';
+import type { ValuesType } from './ValuesType.d';
+
+export type {
+  ArrayElement,
+  AsyncReturnType,
+  DeepPartial,
+  DeepReadonly,
+  DeepRequired,
+  Flatten,
+  FunctionType,
+  If,
+  KeysType,
+  NonNullableType,
+  ObjectType,
+  OnlyObjectKeys,
+  PrettyPrint,
+  RequiredFields,
+  TupleType,
+  ValuesType,
+}

package/dist/types/index.ts

@@ -0,0 +1 @@
+export * from './declaration'