indicator-ui 1.0.44 → 1.0.46

package/dist/types/src/hooks/elementObservers/index.d.ts

@@ -1,4 +1,4 @@
 export * from './useResizeObserver';
-export * from './useIntersectionObserver';
+export * from './useIntersectionObserverOld';
 export * from './useResizeWindowObserver';
 export * from './useScrollableParent';

package/dist/types/src/hooks/elementObservers/{useIntersectionObserver.d.ts → useIntersectionObserverOld.d.ts}

@@ -10,5 +10,5 @@ type FunReturnType = {
     clear: () => void;
     reinitObserver: () => void;
 };
-export declare function useIntersectionObserver<T extends HTMLElement = HTMLElement>(...args: PropsType<T>): FunReturnType;
+export declare function useIntersectionObserverOld<T extends HTMLElement = HTMLElement>(...args: PropsType<T>): FunReturnType;
 export {};

package/dist/types/src/hooks/elementsRefsAdapteers/index.d.ts

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

package/dist/types/src/hooks/elementsRefsAdapteers/useElementRefAdapter.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export type AdapterElementRef<T extends HTMLElement> = React.RefObject<T> | T | null;
+export declare function useElementRefAdapter<T extends HTMLElement>(): (instance: AdapterElementRef<T>) => T | null;

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

@@ -22,3 +22,6 @@ export * from './simpleElement';
 export * from './placement';
 export * from './forms';
 export * from './useScroll';
+export * from './scroll';
+export * from './utils';
+export * from './elementsRefsAdapteers';

package/dist/types/src/hooks/scroll/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './useScrollAnchor';
+export * from './useScrollInfo';
+export * from './useScrollHandler';

package/dist/types/src/hooks/scroll/hooks/useScrollAnchor.d.ts

@@ -0,0 +1,58 @@
+import { ScrollAnchorCommit, ScrollDirectionOptions } from '../types';
+type CommitScroll<T> = (el: T) => ScrollAnchorCommit;
+type RevertScroll<T> = (el: T, commit: ScrollAnchorCommit) => ScrollAnchorCommit;
+type PropsType = ScrollDirectionOptions;
+type FunReturnType<T> = {
+    commitScroll: CommitScroll<T>;
+    revertScroll: RevertScroll<T>;
+};
+/**
+ * Хук для сохранения визуальной позиции скролла
+ * при добавлении элементов в начало списка (prepend) или
+ * при изменение размера `layout` между `зоной видимости`
+ * и `началом элемента`.
+ *
+ * Используется в сценариях, когда новый контент вставляется
+ * выше текущей видимой области, из-за чего увеличивается
+ * scrollHeight, а браузер сохраняет `scrollTop`.
+ *
+ * Хук компенсирует это смещение, сохраняя пользователя
+ * на том же визуальном месте списка.
+ *
+ * Принцип работы:
+ * 1. `commitScroll` — сохраняет текущее состояние скролла и размеры контейнера.
+ * 2. В DOM добавляются элементы в начало списка (prepend).
+ * 3. `revertScroll` — компенсирует изменение scrollHeight,
+ *    корректируя scrollTop так, чтобы видимая область не сместилась.
+ *
+ * ⚠️ ВАЖНО:
+ * Между вызовами `commitScroll` и `revertScroll`
+ * изменение DOM должно происходить до этапа раскраски,
+ * на этапе просчета `layout`.
+ *
+ * ⚠️ ОГРАНИЧЕНИЕ:
+ * Хук предназначен ТОЛЬКО для сценариев добавления элементов
+ * в начало списка.
+ *
+ * @template T HTMLElement или его наследник
+ *
+ * @param props Параметры компенсации скролла
+ *
+ * @param props.scrollVerticalDirection
+ * Направление компенсации по вертикали.
+ * Для prepend-сценариев обычно используется 'bottom' (по умолчанию).
+ *
+ * @param props.scrollHorizontalDirection
+ * Направление компенсации по горизонтали (по умолчанию 'right').
+ *
+ * @returns Объект с методами управления якорем скролла
+ *
+ * @returns.commitScroll
+ * Сохраняет состояние скролла ДО добавления элементов в начало списка.
+ *
+ * @returns.revertScroll
+ * Восстанавливает позицию скролла ПОСЛЕ добавления элементов,
+ * но ДО отрисовки браузером.
+ */
+export declare function useScrollAnchor<T extends HTMLElement>(props?: PropsType): FunReturnType<T>;
+export {};

package/dist/types/src/hooks/scroll/hooks/useScrollHandler.d.ts

@@ -0,0 +1,18 @@
+import { ScrollInfoEvent, SimpleElementType } from '../..';
+import { ScrollAnchorCommit } from '../types';
+import { useScrollAnchor } from './useScrollAnchor';
+import { useScrollInfo } from './useScrollInfo';
+type ScrollEvent<T extends HTMLElement> = ScrollInfoEvent<T> & {
+    commitScroll: () => ScrollAnchorCommit;
+    revertScroll: (commit: ScrollAnchorCommit) => ScrollAnchorCommit;
+};
+type Options<T extends HTMLElement> = Parameters<typeof useScrollInfo<T>>[number] | Parameters<typeof useScrollAnchor<T>>[number];
+type Callback<T extends HTMLElement> = (ev: ScrollEvent<T>) => void;
+export declare function useScrollHandler<T extends HTMLElement>(ref: SimpleElementType<T>, callback: Callback<T>, options?: Options<T>): {
+    getInfo: () => ScrollInfoEvent<T>;
+    getObj: () => T | null;
+    commitScroll: () => ScrollAnchorCommit;
+    revertScroll: (commit: ScrollAnchorCommit) => ScrollAnchorCommit;
+    reinit: () => void;
+};
+export {};

package/dist/types/src/hooks/scroll/hooks/useScrollInfo.d.ts

@@ -0,0 +1,9 @@
+import { ScrollDirectionOptions } from '../..';
+import { ScrollInfoEvent } from '../types';
+type Options = ScrollDirectionOptions & {
+    nearDelta?: number;
+};
+export declare function useScrollInfo<T extends HTMLElement = HTMLElement>(options?: Options): {
+    getInfo: (obj: T) => ScrollInfoEvent<T>;
+};
+export {};

package/dist/types/src/hooks/scroll/index.d.ts

@@ -0,0 +1,2 @@
+export * from './hooks';
+export * from './types';

package/dist/types/src/hooks/scroll/types/base.d.ts

@@ -0,0 +1,4 @@
+export type ScrollDirectionOptions = {
+    verticalDirection?: 'top' | 'bottom';
+    horizontalDirection?: 'left' | 'right';
+};

package/dist/types/src/hooks/scroll/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './scrollInfo';
+export * from './scrollAnchor';
+export * from './base';

package/dist/types/src/hooks/scroll/types/scrollAnchor.d.ts

@@ -0,0 +1,6 @@
+export type ScrollAnchorCommit = {
+    scrollLeft: number;
+    scrollTop: number;
+    scrollHeight: number;
+    scrollWidth: number;
+};

package/dist/types/src/hooks/scroll/types/scrollInfo.d.ts

@@ -0,0 +1,15 @@
+export type ScrollInfoPosition = 'start' | 'end' | 'near-start' | 'near-end' | 'unknown';
+export type ScrollInfoDirection = 'start' | 'end';
+export type ScrollInfoEvent<T extends HTMLElement> = {
+    element: T;
+    canScrollVertical: boolean;
+    canScrollHorizontal: boolean;
+    position: {
+        vertical: ScrollInfoPosition;
+        horizontal: ScrollInfoPosition;
+    };
+    direction: {
+        vertical: ScrollInfoDirection | undefined;
+        horizontal: ScrollInfoDirection | undefined;
+    };
+};

package/dist/types/src/hooks/scroll/utils/index.d.ts

@@ -0,0 +1 @@
+export declare function assertHTMLElement(el: any): asserts el is HTMLElement;

package/dist/types/src/hooks/simpleElement.d.ts

@@ -7,6 +7,7 @@ type SimpleRefElementWorkFunReturnType<T extends HTMLElement> = [
     getObj: () => T | null,
     _getObj: (item: SimpleElementType<T>) => T | null
 ];
+/** @deprecated Используйте {@link useElementRefAdapter} */
 export declare function useSimpleElement<T extends HTMLElement = HTMLElement>(...args: SimpleRefElementWorkPropsType<T>): SimpleRefElementWorkFunReturnType<T>;
 export type SmartRefListType<T extends HTMLElement> = SimpleElementType<T> | Array<SimpleElementType<T>>;
 type SimpleRefListElementWorkPropsType<T extends HTMLElement> = [

package/dist/types/src/hooks/ui-animations/index.d.ts

@@ -1,6 +1,5 @@
 export * from './useModalAnim';
 export * from './useBackgroundModalAnim';
-export * from './useShimmer';
 export * from './useCollapsible';
 export * from './useHoverAutoScrollText';
 export * from './useCarousel';

package/dist/types/src/hooks/useDebouncedInvoker.d.ts

@@ -1 +1,2 @@
+/** @deprecated Используйте {@link useDebounce} */
 export declare function useDebouncedInvoker(callback?: () => void, delay?: number): () => void;

package/dist/types/src/hooks/useElementFixedOffset.d.ts

@@ -5,5 +5,6 @@ type ElementFixedOffset = {
     width: number;
     height: number;
 };
+/** @deprecated */
 export declare function useElementFixedOffset(ref: RefObject<HTMLElement>): ElementFixedOffset;
 export {};

package/dist/types/src/hooks/useFormData.d.ts

@@ -19,4 +19,5 @@ export type UseFormDataReturnType<T extends Record<string, unknown> = Record<str
     clearForm: UseFormDataClearFormType;
     deleteArrayItem: UseFormDataDeleteArrayItemType;
 };
+/** @deprecated */
 export declare function useFormData<T extends Record<string, unknown> = Record<string, unknown>>(value?: T): UseFormDataReturnType<T>;

package/dist/types/src/hooks/useIsErrorField.d.ts

@@ -21,5 +21,6 @@ type PropsType = {
     additionIsErrorFields?: UseIsErrorFieldIsErrorType;
     sensitiveSearch?: boolean;
 };
+/** @deprecated */
 export declare function useIsErrorField(props?: PropsType): UseIsErrorFieldReturnType;
 export {};

package/dist/types/src/hooks/useLoading.d.ts

@@ -1,9 +1,5 @@
 type FunBaseType = (...args: any) => any;
 type FunctionGeneric = FunBaseType | FunBaseType[];
-type PropsType<T extends FunctionGeneric> = [
-    fun: T,
-    initState?: boolean
-];
 type ActionsType = {
     startLoading: () => void;
     stopLoading: () => void;
@@ -56,5 +52,5 @@ type FunReturnType<T extends FunctionGeneric> = [
  * // С начальным состоянием загрузки
  * const [loadUser, isLoading] = useLoading(fetchUser, true);
  */
-export declare function useLoading<T extends FunctionGeneric>(...args: PropsType<T>): FunReturnType<T>;
+export declare function useLoading<T extends FunctionGeneric>(fun: T, initState?: boolean): FunReturnType<T>;
 export {};

package/dist/types/src/hooks/useResettableTimeout.d.ts

@@ -3,6 +3,9 @@ type Timeout = number;
 type Options = {
     initExecute?: boolean;
 };
-type PropsType = [fun: Callback, timeout: Timeout, opt?: Options];
-export declare function useResettableTimeout(...args: PropsType): void;
+export declare function useResettableTimeout(_fun: Callback, timeout: Timeout, opt?: Options): {
+    schedule: (instance: () => void) => void;
+    executeAndSchedule: () => Promise<void>;
+    clear: () => void;
+};
 export {};

package/dist/types/src/hooks/useSafeCallback.d.ts

@@ -2,6 +2,7 @@ type Callback = (...args: any[]) => any;
 type PropsType = [
     callback?: Callback
 ];
+/** @deprecated */
 export declare function useSafeCallback(...args: PropsType): {
     getPrevCallback: () => Callback | undefined;
     getCallback: () => Callback | undefined;

package/dist/types/src/hooks/useScroll.d.ts

@@ -3,6 +3,7 @@ type PropsType<T extends HTMLElement> = [
     obj: SimpleElementType<T>,
     callback?: (ev: Event) => void
 ];
+/** @deprecated */
 export declare function useScroll<T extends HTMLElement = HTMLElement>(...args: PropsType<T>): {
     reinit: () => void;
     destruct: () => void;

package/dist/types/src/hooks/useScrollIndicators.d.ts

@@ -11,6 +11,7 @@ type PropsType<T extends HTMLElement = HTMLElement, W extends HTMLElement = HTML
  * Добавляет эффект скролла к элементу. Требует рефки на сам контейнер для скролла и обертку для него.
  *
  * Учтите, обертка будет иметь `position: relative;`.
+ * @deprecated
  * */
 export declare function useScrollIndicators(...args: PropsType): void;
 export {};

package/dist/types/src/hooks/useSmartScroll/hooks/useDragScroll.d.ts

@@ -1,6 +1,6 @@
-import { default as React } from 'react';
-type PropsType<T> = [
-    ref: React.RefObject<T | null>,
+import { SimpleElementType } from '../..';
+type PropsType<T extends HTMLElement> = [
+    ref: SimpleElementType<T>,
     options?: {
         disabled?: boolean;
     }

package/dist/types/src/hooks/useSmartScroll/hooks/useTouchmove.d.ts

@@ -1,6 +1,6 @@
-import { default as React } from 'react';
-type PropsType<T> = [
-    ref: React.RefObject<T | null>,
+import { SimpleElementType } from '../..';
+type PropsType<T extends HTMLElement> = [
+    ref: SimpleElementType<T>,
     callbacks?: {
         onTouchmoveDown?: () => void;
         onTouchmoveUp?: () => void;

package/dist/types/src/hooks/useSmartScroll/hooks/useWheelEvent.d.ts

@@ -1,6 +1,6 @@
-import { default as React } from 'react';
-type PropsType<T> = [
-    ref: React.RefObject<T | null>,
+import { SimpleElementType } from '../..';
+type PropsType<T extends HTMLElement> = [
+    ref: SimpleElementType<T>,
     callbacks?: {
         onWheelDown?: () => void;
         onWheelUp?: () => void;

package/dist/types/src/hooks/useSyncedStateRef.d.ts

@@ -1,3 +1 @@
-type PropsType<DataType> = [initialValue?: DataType];
-export declare function useSyncedStateRef<DataType = unknown>(...args: PropsType<DataType>): readonly [DataType, import('react').Dispatch<import('react').SetStateAction<DataType>>, () => DataType];
-export {};
+export declare function useSyncedStateRef<DataType = unknown>(initialValue?: DataType): readonly [DataType, import('react').Dispatch<import('react').SetStateAction<DataType>>, () => DataType];

package/dist/types/src/hooks/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './useTimeout';
+export * from './useDebounce';
+export * from './useLockedCallback';
+export * from './useRefAdapter';
+export * from './useStableCallbackInvoke';
+export * from './useIntersectionObserver';

package/dist/types/src/hooks/utils/useDebounce.d.ts

@@ -0,0 +1,37 @@
+type Args = any[];
+type Callback<TArgs extends Args> = (...args: TArgs) => void;
+/**
+ * React-хук, возвращающий debounced-версию функции.
+ *
+ * Функция будет вызвана только после того, как пройдет `delay` миллисекунд
+ * с момента последнего вызова. Каждый новый вызов сбрасывает таймер.
+ *
+ * Хук корректно:
+ * - работает с аргументами через `...args`
+ * - обновляет callback без сброса таймера
+ * - очищает таймер при размонтировании компонента
+ *
+ * Подходит для:
+ * - обработки ввода пользователя (search, filters)
+ * - resize / scroll обработчиков
+ * - любых часто вызываемых, но дорогих операций
+ *
+ * @template TArgs Тип аргументов callback-функции
+ *
+ * @param callback Функция, выполнение которой нужно задебаунсить
+ * @param delay Задержка в миллисекундах
+ *
+ * @returns Debounced-функция с той же сигнатурой, что и `callback`
+ *
+ * @example
+ * const onChange = useDebounce(
+ *   (value: string) => {
+ *     fetchUsers(value)
+ *   },
+ *   300
+ * )
+ *
+ * onChange('hello')
+ */
+export declare function useDebounce<TArgs extends Args>(callback: Callback<TArgs>, delay: number): (...args: TArgs) => void;
+export {};

package/dist/types/src/hooks/utils/useIntersectionObserver.d.ts

@@ -0,0 +1,5 @@
+export declare function useIntersectionObserve(callback: IntersectionObserverCallback, options: IntersectionObserverInit): {
+    observe: (target: Element) => void;
+    unobserve: (target: Element) => void;
+    reinitObserver: () => void;
+};

package/dist/types/src/hooks/utils/useLockedCallback.d.ts

@@ -0,0 +1,26 @@
+type Args = any[];
+/**
+ * React-хук, возвращающий эксклюзивную версию callback-функции.
+ *
+ * Функция может быть вызвана многократно, но пока выполняется,
+ * повторные вызовы будут **игнорироваться**.
+ *
+ * Полезно для:
+ * - кнопок Submit (защита от double click)
+ * - async side-effects, которые нельзя выполнять параллельно
+ * - любых операций, где нужен mutex на выполнение
+ *
+ * @template TArgs Тип аргументов callback-функции
+ * @param callback Асинхронная или синхронная функция, которую нужно защитить от параллельных вызовов
+ * @returns Функцию с той же сигнатурой, но блокирующую повторные вызовы пока выполняется
+ *
+ * @example
+ * const save = useLockedCallback(async (data: string) => {
+ *   await api.save(data)
+ * })
+ *
+ * save('hello') // выполнится
+ * save('world') // проигнорируется, если предыдущий вызов ещё не завершился
+ */
+export declare function useLockedCallback<TArgs extends Args>(callback: (...args: TArgs) => Promise<any> | void): (...args: TArgs) => void | Promise<any>;
+export {};

package/dist/types/src/hooks/utils/useRefAdapter.d.ts

@@ -0,0 +1 @@
+export declare function useRefAdapter<T>(initialValue: T): readonly [() => T, (instance: T) => void];

package/dist/types/src/hooks/utils/useStableCallbackInvoke.d.ts

@@ -0,0 +1,5 @@
+type Fun = (...args: any[]) => any;
+type ReturnType<T extends Fun | undefined> = T extends undefined ? (...args: any[]) => void : T;
+export declare function useStableCallbackInvoke<T extends undefined>(callback: T): ReturnType<T>;
+export declare function useStableCallbackInvoke<T extends Fun>(callback: T): ReturnType<T>;
+export {};

package/dist/types/src/hooks/utils/useTimeout.d.ts

@@ -0,0 +1,27 @@
+type SetTimeoutFn = (callback: () => void, delay?: number) => void;
+type ClearTimeoutFn = () => void;
+/**
+ * React-хук для управления единичным таймером.
+ *
+ * Хук возвращает кортеж `[setTimeout, clearTimeout]`, который позволяет:
+ * - установить таймер, который выполнит переданную функцию через заданную задержку
+ * - сбросить активный таймер, если он существует
+ * - автоматически очищать таймер при размонтировании компонента
+ *
+ * Повторный вызов `setTimeout` сбрасывает предыдущий таймер.
+ *
+ * @example
+ * const [setTimeout, clearTimeout] = useTimeout()
+ *
+ * // Таймер сработает через 500 мс
+ * setTimeout(() => {
+ *   console.log('Привет через 500 мс')
+ * }, 500)
+ *
+ * // Сброс таймера
+ * clearTimeout()
+ *
+ * @returns [setTimeout, clearTimeout] — функции для управления таймером
+ */
+export declare function useTimeout(): [SetTimeoutFn, ClearTimeoutFn];
+export {};

package/dist/types/src/types/mixins.d.ts

@@ -20,11 +20,16 @@ export type Undefinable<T> = undefined | (IsObject<T> extends true ? IsArray<T>
     [K in keyof T]?: T[K] | undefined;
 } : T);
 export type Merge<A extends Record<any, any>, B extends Record<any, any>> = Omit<A, keyof B> & B;
-export type AsProps<T extends ElementType, P extends Record<string, any> = {}, IR = React.ComponentRef<T>> = Merge<React.ComponentPropsWithoutRef<T>, {
+type ComponentAttributes = {
+    [K in PropertyKey]: unknown;
+};
+export type AsProps<T extends ElementType, P extends ComponentAttributes = {}, IR = never> = Merge<React.ComponentPropsWithoutRef<T>, {
     as?: T;
-} & InstanceRefAttributes<IR> & P>;
+} & (IR extends never ? {} : InstanceRefAttributes<IR>) & P>;
+export type ComponentPropsWithoutInstanceRef<T extends ElementType> = Omit<React.ComponentProps<T>, keyof InstanceRefAttributes<T>>;
 export type InstanceRefAttributes<T> = {
-    instanceRef?: React.Ref<T>;
+    instanceRef?: React.RefObject<T> | React.RefCallback<T> | null;
 };
-export type ComponentPropsWithoutInstanceRef<T extends ElementType> = Omit<React.ComponentProps<T>, keyof InstanceRefAttributes<T>>;
 export type ComponentInstanceRef<T extends ElementType> = React.ComponentProps<T> extends InstanceRefAttributes<infer Method> ? Method : never;
+export type AcceptsComponentProps<T extends ElementType, P extends ComponentAttributes> = React.ComponentPropsWithoutRef<T> extends P ? T : never;
+export {};

package/dist/types/src/ui/Breadcrumbs/ui/BreadcrumbButton.d.ts

@@ -1,10 +1,12 @@
 import { default as React, ElementType } from 'react';
-import { AsProps, Merge } from '../../../types';
-type PropsType<T extends ElementType> = Merge<AsProps<T>, {
+import { AsProps } from '../../../types';
+type PropsType<T extends ElementType> = AsProps<T, {
+    text?: React.ReactNode;
+    icon?: React.ReactNode;
     current?: boolean;
     className?: string;
     children?: React.ReactNode;
     type?: 'text' | 'button-primary' | 'button-gray';
-}>;
+}, React.ComponentRef<T>>;
 export declare function BreadcrumbButton<T extends ElementType = 'button'>(props: PropsType<T>): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,9 +1,10 @@
-import { AsProps, Merge } from '../../../types';
+import { AsProps } from '../../../types';
 import { default as React, ElementType } from 'react';
 import { Divider } from './Divider';
-type PropsType<T extends ElementType> = Merge<AsProps<T>, {
+type PropsType<T extends ElementType> = AsProps<T, {
     children?: React.ReactNode;
+    className?: string;
     type?: React.ComponentProps<typeof Divider>['type'];
-}>;
+}, React.ComponentRef<T>>;
 export declare function Breadcrumbs<T extends ElementType = 'div'>(props: PropsType<T>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/src/ui/Buttons/types/ButtonTypes.d.ts

@@ -43,4 +43,4 @@ export type ButtonPropsType<T extends React.ElementType> = AsProps<T, {
     theme?: "light" | "dark" | undefined;
     isLoading?: boolean;
     counter?: React.ReactNode;
-}>;
+}, React.ComponentProps<'button'>>;

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

@@ -8,7 +8,8 @@ type PropsType<C extends ElementType, W extends ElementType> = AsProps<C, {
     wrapperStyle?: CSSProperties;
     onUpdateState?: (state: CollapseState) => void;
     initialState?: CollapseState;
-}>;
+    style?: CSSProperties;
+}, React.ComponentRef<C>>;
 type RefType = Omit<CollapsibleReturnType, 'getWrapperInitStyle' | 'getContentInitStyle'>;
 /**
  * Collapse — полиморфный JSX-компонент, являющийся компонентной реализацией хука `useCollapsible`.

package/dist/types/src/ui/DropdownV2/ui/DropdownItemV2.d.ts

@@ -7,7 +7,8 @@ type PropsType<T extends React.ElementType> = AsProps<T, {
     avatar?: string;
     subtitle?: React.ReactNode;
     icon?: React.ReactNode;
+    className?: string;
     size?: 'small' | 'medium';
-}>;
+}, React.ComponentRef<T>>;
 export declare function DropdownItemV2<T extends React.ElementType = 'li'>(props: PropsType<T>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/src/ui/Tag/ui/FilterTag.d.ts

@@ -7,7 +7,7 @@ type PropsType<T extends React.ElementType> = AsProps<T, {
     label?: React.ReactNode;
     onClose?: () => void;
     active?: boolean;
-}>;
+}, React.ComponentRef<T>>;
 export declare const _FilterTag: <T extends React.ElementType>(props: PropsType<T>, ref: React.Ref<RefType<T>>) => import("react/jsx-runtime").JSX.Element;
 export declare const FilterTag: <T extends React.ElementType = "button">(props: PropsType<T> & React.RefAttributes<RefType<T>>) => JSX.Element;
 export {};

package/dist/types/src/ui/Tag/ui/TagCount.d.ts

@@ -4,6 +4,6 @@ type PropsType<T extends React.ElementType> = AsProps<T, {
     count?: React.ReactNode;
     color?: 'gray' | 'color' | 'white';
     size?: 'small' | 'medium' | 'large';
-}>;
+}, React.ComponentRef<T>>;
 export declare function TagCount<T extends React.ElementType = 'span'>(props: PropsType<T>): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -9,8 +9,9 @@ type PropsType<T extends React.ElementType> = AsProps<T, {
     error?: boolean;
     hover?: boolean;
     disabled?: boolean;
+    className?: string;
     /** @deprecated */
     theme?: "light" | "dark";
-}>;
+}, React.ComponentRef<T>>;
 export declare function ToggleBase<T extends React.ElementType>(props: PropsType<T>): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 import { AsProps } from '../../../types';
 export type PropsType = AsProps<'div', {
     /**
@@ -12,5 +13,5 @@ export type PropsType = AsProps<'div', {
      * */
     size?: '20' | '24' | '32' | '40' | '48' | '64' | '72' | '80' | '96' | '120' | '144' | '160' | number;
     disabled?: boolean;
-}>;
+}, React.ComponentRef<'div'>>;
 export declare function UserPick(props: PropsType): import("react/jsx-runtime").JSX.Element;

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

@@ -29,3 +29,4 @@ export * from './formFields';
 export * from './Breadcrumbs';
 export * from './DropdownV2';
 export * from './Collapse';
+export * from './visual';

package/dist/types/src/ui/visual/ScrollHint/hooks/index.d.ts

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

package/dist/types/src/ui/visual/ScrollHint/hooks/useContainer.d.ts

@@ -0,0 +1,7 @@
+import { ElementType } from 'react';
+import { InstanceRef, PropsType as _PropsType } from '../types';
+type PropsType<T extends ElementType> = Pick<_PropsType<T>, "instanceRef">;
+export declare function useContainer<T extends ElementType>(props: PropsType<T>): {
+    containerRef: import('react').RefObject<InstanceRef<T>>;
+};
+export {};

package/dist/types/src/ui/visual/ScrollHint/hooks/useHintPosition.d.ts

@@ -0,0 +1,13 @@
+import { ScrollDirectionOptions } from '../../../../hooks';
+type PropsType = ScrollDirectionOptions;
+export declare function useHintPosition(props: PropsType): {
+    calcHorizontalHintPosition: (scroll: number, scrollSize: number, clientSize: number) => {
+        start: number;
+        end: number;
+    };
+    calcVerticalHintPosition: (scroll: number, scrollSize: number, clientSize: number) => {
+        start: number;
+        end: number;
+    };
+};
+export {};

package/dist/types/src/ui/visual/ScrollHint/hooks/useScrollHint.d.ts

@@ -0,0 +1,3 @@
+import { ElementType } from 'react';
+import { DefaultElementType, PropsType } from '../types';
+export declare function useScrollHint<T extends ElementType = DefaultElementType>(props: PropsType<T>): {};

package/dist/types/src/ui/visual/ScrollHint/hooks/useScrollListener.d.ts

@@ -0,0 +1,7 @@
+import { ElementType } from 'react';
+import { useContainer } from './useContainer';
+type PropsType<T extends ElementType> = Pick<ReturnType<typeof useContainer<T>>, 'containerRef'> & {
+    onScrollHandler: (ev: Event) => void;
+};
+export declare function useScrollListener<T extends ElementType>(props: PropsType<T>): {};
+export {};

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

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

package/dist/types/src/ui/visual/ScrollHint/styles/components/index.d.ts

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

package/dist/types/src/ui/visual/ScrollHint/styles/index.d.ts

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