indicator-ui 0.1.46 → 0.1.48

package/dist/types/src/ui/formFields/FormSelectField/ui/FormSelectField.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { ComponentRefType } from "../../../../../../types";
+import { FormSelectFieldBase } from './FormSelectFieldBase';
+import { FormFieldWrapper } from '../../FormFieldWrapper';
+type RefType = ComponentRefType<typeof FormFieldWrapper>;
+type PropsType<D, M extends boolean> = React.ComponentProps<typeof FormSelectFieldBase<D, M>> & React.ComponentProps<typeof FormFieldWrapper>;
+export declare const FormSelectField: <D, M extends boolean = false>(props: PropsType<D, M> & React.RefAttributes<RefType>) => React.ReactElement | null;
+export {};

package/dist/types/src/ui/formFields/FormSelectField/ui/FormSelectFieldBase.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+import { FieldPropsType } from "../../../../hooks";
+import { DropdownItemPropsType } from "../../../../ui";
+import { FormFieldBase } from '../../FormField';
+type SelectFieldOptionsExtendItemType<T> = DropdownItemPropsType & {
+    value: T;
+    label?: string;
+};
+type SelectFieldOptionsItemType<T> = SelectFieldOptionsExtendItemType<T> | T;
+type SelectFieldOptionsType<T> = Array<SelectFieldOptionsItemType<T>>;
+type SelectFieldValueType<D, M> = M extends true ? Array<D> : D;
+type BasePropsType<D, M extends boolean> = {
+    options?: SelectFieldOptionsType<D>;
+    multiple?: M;
+    theme?: "light" | "dark";
+    disabled?: boolean;
+    required?: boolean;
+};
+type PropsType<D, M extends boolean> = Omit<React.ComponentProps<typeof FormFieldBase>, keyof BasePropsType<D, M> | keyof FieldPropsType<SelectFieldValueType<D, M>>> & FieldPropsType<SelectFieldValueType<D, M>> & BasePropsType<D, M>;
+export declare function FormSelectFieldBase<D, M extends boolean = false>(props: PropsType<D, M>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/ui/formFields/FormSelectField/ui/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FormSelectFieldBase';
+export * from './FormSelectField';

package/dist/types/src/ui/formFields/FormSwitcherField/index.d.ts

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

package/dist/types/src/ui/formFields/FormSwitcherField/ui/FormSwitcherField.d.ts

@@ -0,0 +1,5 @@
+import { TogglePropsType } from "../../../../ui";
+import { FieldPropsType } from "../../../../hooks";
+type PropsType = Omit<TogglePropsType, keyof FieldPropsType<boolean>> & FieldPropsType<boolean>;
+export declare function FormSwitcherField(props: PropsType): JSX.Element;
+export {};

package/dist/types/src/ui/formFields/FormSwitcherField/ui/index.d.ts

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

package/dist/types/src/ui/formFields/FormTextareaField/index.d.ts

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

package/dist/types/src/ui/formFields/FormTextareaField/styles/index.d.ts

@@ -0,0 +1 @@
+export { default as TextareaFieldStyle } from './TextareaField.module.scss';

package/dist/types/src/ui/formFields/FormTextareaField/ui/FormTextareaField.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { FieldPropsType } from "../../../../hooks";
+type BasePropsType = FieldPropsType<string> & {
+    /**
+     * Изменяет размер текстового поля, если текст не помещается.
+     *
+     * По умолчанию: ```false```
+     * */
+    autoResize?: boolean;
+    theme?: "light" | "dark";
+};
+type PropsType = Omit<React.ComponentProps<'textarea'>, keyof BasePropsType> & BasePropsType;
+export declare function FormTextareaField(props: PropsType): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/ui/formFields/FormTextareaField/ui/index.d.ts

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

package/dist/types/src/ui/formFields/extends/index.d.ts

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

package/dist/types/src/ui/formFields/extends/style/index.d.ts

@@ -0,0 +1,2 @@
+export { default as DropdownArrowStyle } from './DropdownArrow.module.scss';
+export { default as InputInnerButtonStyle } from './InputInnerButton.module.scss';

package/dist/types/src/ui/formFields/extends/ui/DropdownArrow.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+type PropsType = React.ComponentProps<'button'> & {
+    open?: boolean;
+};
+export declare function DropdownArrow(props: PropsType): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/ui/formFields/extends/ui/InputInnerButton.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+type PropsType = React.ComponentProps<'button'> & {
+    icon: React.ReactNode;
+    color: 'gray' | 'red';
+};
+export declare function InputInnerButton(props: PropsType): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/ui/formFields/extends/ui/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DropdownArrow';
+export * from './InputInnerButton';

package/dist/types/src/ui/formFields/index.d.ts

@@ -0,0 +1,6 @@
+export * from './FormField';
+export * from './FormSelectField';
+export * from './FormFieldWrapper';
+export * from './FormSwitcherField';
+export * from './FormRadioField';
+export * from './FormTextareaField';

package/dist/types/src/ui/index.d.ts

@@ -25,3 +25,4 @@ export * from './PlayButton';
 export * from './DateTimePicker';
 export * from './Tooltip';
 export * from './Dropdown';
+export * from './formFields';

package/docs/Notes.md

@@ -53,3 +53,137 @@ newEl.addEventListener("dragover", e => {
 
 `Keydown` событие срабатывает только на сфокусированном объекте и всплывает вверх по дереву, пока не встретит слушатель. 
 После обработки слушателем идет дальше - искать следующий (если не отменить всплытие). 
+
+
+
+## Про `TS`
+
+### Бесконечная рекурсия в типах или ***Type instantiation is excessively deep and possibly infinite.***
+
+Давайте рассмотрим такой пример рекурсивных типов.
+
+```typescript
+type GetBaseKeyChains<P extends string, T> =
+    IsAny<T> extends false
+        ? P | `${P}${GetDeepKeyChains<T> | GetArrayKeyChains<T>}`
+        : P | `${P}${'.' | '['}${string}`
+
+type GetArrayKeyChains<T> =
+    IsArray<T> extends false
+        ? never
+        : ClearArrayType<T> extends infer Arr
+            ? IsTuple<Arr> extends true
+                ? {
+                    [K in Extract<keyof Arr, `${number}`>]: GetBaseKeyChains<`[${K}]`, Arr[K]>
+                }[Extract<keyof Arr, `${number}`>]
+                : Arr extends any[]
+                    ? `[${number}]` | GetBaseKeyChains<`[${number}]`, Arr[number]>
+                    : never
+            : never
+
+type GetDeepKeyChains<T> =
+    IsObjectType<T> extends false
+        ? never
+        : ClearObjectType<T> extends infer Form
+            ? {
+                [K in Extract<keyof Form, string>]: GetBaseKeyChains<`.${K}`, Form[K]>
+            }[Extract<keyof Form, string>]
+            : never
+
+
+export type FormPath<T> = '' |
+    (
+        IsObjectType<T> extends false
+            ? GetArrayKeyChains<T>
+            : ClearObjectType<T> extends infer Form
+                ? {
+                    [K in Extract<keyof Form, string>]: GetBaseKeyChains<`${K}`, Form[K]>
+                }[Extract<keyof Form, string>]
+                : never
+        )
+```
+
+Как видно из примера, `GetBaseKeyChains` вызывает `GetArrayKeyChains` и `GetDeepKeyChains`,
+а они в свою очередь вызывают его, что создаёт рекурсию.
+
+Все бы хорошо, тип рабочий, всё правильно делает, но когда ты начинаешь его использовать в других типах,
+которые используются в других типах и т. д., `ts` начинает офигевать от "глубины" наших намерений и предлагает поумерить пыл.
+
+```
+TS2589: Type instantiation is excessively deep and possibly infinite.
+```
+
+Ошибка говорит о том, что слишком глубоко и, возможно, бесконечно.
+Чтобы не было бесконечно, у рекурсии обязательно должно быть условие выхода.
+Есть ли оно у этой?
+
+Да, есть — `IsObjectType<T> extends false ? never : ...` или `IsArray<T> extends false ? never :` или `IsAny<T> extends false ...`
+
+Но почему же `ts` всё равно ругается на `possibly infinite`? Ах да — `excessively deep`, `ts` ленивый.
+Если он видит, что тип вывести слишком тяжело, он такой: "Не братан, по-моему, тут слишком глубоко и бесконечно".
+
+На самом деле это круто, что есть такой защитный механизм, но как всё же победить это? Давайте разбираться.
+
+Один из способов (и это единственный, который мы рассмотрим, но он довольно логичный и исходит из защиты от слишком
+глубокой рекурсии в нормальных языках программирования) — это ограничить глубину рекурсии.
+
+```typescript
+type SafeRecursiveArr = [1, 2, 3, 4, 5]
+type SafeRecursiveStep<T> = T extends [infer _, ...infer Rest] ? Rest : never
+type CanContinueRecursive<T> = SafeRecursiveStep<T> extends never ? false : true
+```
+
+Здесь мы создали пару конструкций, которые помогут отслеживать возможность продолжать спуск и
+уменьшать счётчик допустимой глубины.
+
+Круто, теперь имплементируем это в наши изначальные типы.
+
+```typescript
+type GetBaseKeyChains<P extends string, T, SafeArr> =
+    CanContinueRecursive<SafeArr> extends false
+        ? never
+        : IsAny<T> extends false
+            ? P | `${P}${GetDeepKeyChains<T, SafeRecursiveStep<SafeArr>> | GetArrayKeyChains<T, SafeRecursiveStep<SafeArr>>}`
+            : P | `${P}${'.' | '['}${string}`
+
+type GetArrayKeyChains<T, SafeArr> =
+    CanContinueRecursive<SafeArr> extends false
+        ? never
+        : IsArray<T> extends false
+            ? never
+            : ClearArrayType<T> extends infer Arr
+                ? IsTuple<Arr> extends true
+                    ? {
+                        [K in Extract<keyof Arr, `${number}`>]: GetBaseKeyChains<`[${K}]`, Arr[K], SafeRecursiveStep<SafeArr>>
+                    }[Extract<keyof Arr, `${number}`>]
+                    : Arr extends any[]
+                        ? `[${number}]` | GetBaseKeyChains<`[${number}]`, Arr[number], SafeRecursiveStep<SafeArr>>
+                        : never
+                : never
+
+type GetDeepKeyChains<T, SafeArr> =
+    CanContinueRecursive<SafeArr> extends false
+        ? never
+        : IsObjectType<T> extends false
+            ? never
+            : ClearObjectType<T> extends infer Form
+                ? {
+                    [K in Extract<keyof Form, string>]: GetBaseKeyChains<`.${K}`, Form[K], SafeRecursiveStep<SafeArr>>
+                }[Extract<keyof Form, string>]
+                : never
+
+
+export type FormPath<T> = '' |
+    (
+        IsObjectType<T> extends false
+            ? GetArrayKeyChains<T, SafeRecursiveArr>
+            : ClearObjectType<T> extends infer Form
+                ? {
+                    [K in Extract<keyof Form, string>]: GetBaseKeyChains<`${K}`, Form[K], SafeRecursiveArr>
+                }[Extract<keyof Form, string>]
+                : never
+        )
+```
+
+Теперь `ts` будет нормально реагировать на использование типа `FormPath` в других типах,
+и можно не бояться увидеть сообщение об ошибке.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indicator-ui",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "main": "dist/index.js",
   "types": "dist/types/src/index.d.ts",
   "style": "dist/index.css",
@@ -63,7 +63,7 @@
     "tsconfig-paths-webpack-plugin": "^4.2.0",
     "tslib": "^2.8.1",
     "typed-css-modules-webpack-plugin": "^0.2.0",
-    "typescript": "^5.7.3",
+    "typescript": "^5.9.3",
     "webpack": "^5.97.1",
     "webpack-cli": "^6.0.1",
     "webpack-dev-server": "^5.2.0"

package/dist/scss/ui/InputFields/index.scss

@@ -1,7 +0,0 @@
-@forward "FlexField";
-@forward "InputFieldWrapper";
-@forward "RadioField";
-@forward "SelectField";
-@forward "SwitcherField";
-@forward "TextareaField";
-@forward "InputField";

package/dist/types/src/hooks/forms/useForms.d.ts

@@ -1,3 +0,0 @@
-type PropsType = [];
-export declare function useForms(...args: PropsType): void;
-export {};