indicator-ui 1.0.6 → 1.0.8

package/dist/types/src/hooks/controlsInput/useDrag.d.ts

@@ -1,4 +1,4 @@
-import { useSimpleRefElementWork } from '..';
+import { useSimpleElement } from '..';
 type DragStateType = {
     fromX: number;
     fromY: number;
@@ -7,7 +7,7 @@ type DragStateType = {
     status: 'start' | 'moving' | 'end';
 };
 type PropsType = [
-    ref: Parameters<typeof useSimpleRefElementWork>[number],
+    ref: Parameters<typeof useSimpleElement>[number],
     callback: (data: DragStateType) => void,
     options?: {
         dropDraggingOnLeave?: boolean;

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

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

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

@@ -1,5 +1,5 @@
-import { useSimpleRefListElementWork } from '..';
-type UseSimpleRefListElementWorkPropsType<T extends HTMLElement> = Parameters<typeof useSimpleRefListElementWork<T>>['0'];
+import { useSimpleElementsList } from '..';
+type UseSimpleRefListElementWorkPropsType<T extends HTMLElement> = Parameters<typeof useSimpleElementsList<T>>['0'];
 type PropsType<T extends HTMLElement> = [
     ref: UseSimpleRefListElementWorkPropsType<T>,
     callback: IntersectionObserverCallback,

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

@@ -1,7 +1,6 @@
-import { useSimpleRefListElementWork } from '..';
-type UseSimpleRefListElementWorkPropsType<T extends HTMLElement> = Parameters<typeof useSimpleRefListElementWork<T>>['0'];
+import { SimpleElementType } from '..';
 type PropsType<T extends HTMLElement> = [
-    ref: UseSimpleRefListElementWorkPropsType<T>,
+    ref: SimpleElementType<T>[] | SimpleElementType<T>,
     callback: ResizeObserverCallback
 ];
 type FunReturnType = {

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

@@ -0,0 +1,12 @@
+import { SimpleElementType, useResizeObserver, useScroll } from '..';
+type ScrollCallback = Exclude<Parameters<typeof useScroll>[1], undefined>;
+type ResizeCallback = Exclude<Parameters<typeof useResizeObserver>[1], undefined>;
+type PropsType<T extends HTMLElement> = [
+    obj: SimpleElementType<T>,
+    callbacks?: {
+        onResize?: ResizeCallback;
+        onScroll?: ScrollCallback;
+    }
+];
+export declare function useScrollableParent<T extends HTMLElement = HTMLElement>(...args: PropsType<T>): void;
+export {};

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

@@ -17,6 +17,7 @@ export * from './ui-animations';
 export * from './modalWindows';
 export * from './controlsInput';
 export * from './elementObservers';
-export * from './simpleRefWork';
+export * from './simpleElement';
 export * from './placement';
 export * from './forms';
+export * from './useScroll';

package/dist/types/src/hooks/modalWindows/useBackdropModal.d.ts

@@ -1,11 +1,11 @@
 import { RefObject } from 'react';
-import { SmartRefType } from '..';
+import { SimpleElementType } from '..';
 import { useBackgroundModalAnim } from '../ui-animations';
 type UseBackgroundModalAnimOptionsPropsType = Exclude<Parameters<typeof useBackgroundModalAnim>['1'], undefined>;
 type OptionsType<C extends HTMLElement = HTMLElement> = UseBackgroundModalAnimOptionsPropsType & {
     containerClickAreaRef?: RefObject<C | null>;
 };
-type PropsType<T extends HTMLElement = HTMLElement> = [ref: SmartRefType<T>, options?: OptionsType];
+type PropsType<T extends HTMLElement = HTMLElement> = [ref: SimpleElementType<T>, options?: OptionsType];
 /**
  * Хук для backdrop-модального окна.
  *

package/dist/types/src/hooks/modalWindows/useModal.d.ts

@@ -1,10 +1,10 @@
-import { SmartRefType } from '..';
+import { SimpleElementType } from '..';
 import { useInteractiveZone } from '../useInteractiveZone';
 import { useModalAnim } from '../ui-animations';
 type UseModalAnimOptionsPropsType = Exclude<Parameters<typeof useModalAnim>['1'], undefined>;
 type UseInteractiveZoneOptionsPropsType = Exclude<Parameters<typeof useInteractiveZone>['2'], undefined>;
 type OptionsType = Pick<UseInteractiveZoneOptionsPropsType, 'addition'> & UseModalAnimOptionsPropsType;
-type PropsType<T extends HTMLElement = HTMLElement> = [ref: SmartRefType<T>, options?: OptionsType];
+type PropsType<T extends HTMLElement = HTMLElement> = [ref: SimpleElementType<T>, options?: OptionsType];
 /**
  * Хук для модального окна.
  *

package/dist/types/src/hooks/placement/useSmartPlacementResolver.d.ts

@@ -1,13 +1,13 @@
 import { CSSProperties } from 'react';
 import { calculateAvailablePosition } from './calculateAvailablePosition';
-import { SmartRefType } from '..';
+import { SimpleElementType } from '..';
 type CalculateAvailablePositionPropsType = Parameters<typeof calculateAvailablePosition>['0'];
 type NewPlacementPosType = ReturnType<typeof calculateAvailablePosition>;
 type PropsType = [
-    ref: SmartRefType<HTMLElement>,
+    ref: SimpleElementType<HTMLElement>,
     options?: Omit<CalculateAvailablePositionPropsType, 'objRect' | 'parentRect' | 'windowRect'> & {
-        parentRef?: SmartRefType<HTMLElement>;
-        windowRef?: SmartRefType<HTMLElement>;
+        parentRef?: SimpleElementType<HTMLElement>;
+        windowRef?: SimpleElementType<HTMLElement>;
     }
 ];
 type FunReturnType = {

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

@@ -0,0 +1,20 @@
+import { RefObject } from 'react';
+export type SimpleElementType<T extends HTMLElement> = RefObject<T | null> | T | null | undefined | (() => T | null | undefined);
+type SimpleRefElementWorkPropsType<T extends HTMLElement> = [
+    ref?: SimpleElementType<T>
+];
+type SimpleRefElementWorkFunReturnType<T extends HTMLElement> = [
+    getObj: () => T | null,
+    _getObj: (item: SimpleElementType<T>) => T | null
+];
+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> = [
+    ref?: SmartRefListType<T>
+];
+type SimpleRefListElementWorkFunReturnType<T extends HTMLElement> = [
+    getObjects: () => Array<T | null>,
+    _getObjects: (item: SmartRefListType<T>) => Array<T | null>
+];
+export declare function useSimpleElementsList<T extends HTMLElement = HTMLElement>(...args: SimpleRefListElementWorkPropsType<T>): SimpleRefListElementWorkFunReturnType<T>;
+export {};

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

@@ -1,4 +1,11 @@
-export declare function COLLAPSIBLE_ANIM(): {
-    appear: (obj: HTMLElement, timeline: gsap.core.Timeline, height: number) => gsap.core.Timeline;
-    disappear: (obj: HTMLElement, timeline: gsap.core.Timeline, height: number) => gsap.core.Timeline;
+type PropsType = [
+    wrapper: HTMLElement,
+    content: HTMLElement,
+    timeline: gsap.core.Timeline
+];
+export declare function COLLAPSIBLE_ANIM(...args: PropsType): {
+    appear: (height: number) => gsap.core.Timeline;
+    disappear: () => gsap.core.Timeline;
+    changeHeight: (height: number) => gsap.core.Timeline;
 };
+export {};

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

@@ -1,8 +1,8 @@
 import { CSSProperties } from 'react';
 import { BACKDROP_MODAL_ANIMATIONS } from './assets';
-import { SmartRefType } from '..';
+import { SimpleElementType } from '..';
 type OptionsType<T extends HTMLElement = HTMLElement> = {
-    targetRef?: SmartRefType<T>;
+    targetRef?: SimpleElementType<T>;
     onViewing?: () => void;
     onHiding?: () => void;
     backdropClassName?: string;
@@ -13,7 +13,7 @@ type OptionsType<T extends HTMLElement = HTMLElement> = {
     };
     backdropColor?: string;
 };
-type PropsType<T extends HTMLElement = HTMLElement> = [ref: SmartRefType<T>, options?: OptionsType];
+type PropsType<T extends HTMLElement = HTMLElement> = [ref: SimpleElementType<T>, options?: OptionsType];
 type AnimationsTypes = keyof ReturnType<typeof BACKDROP_MODAL_ANIMATIONS>;
 /**
  * Хук для анимации backdrop-модального окна.

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

@@ -1,9 +1,9 @@
 import { CSSProperties } from 'react';
-import { SmartRefType } from '..';
+import { SimpleElementType } from '..';
 import { CAROUSEL_ANIM } from './assets';
 type PropsType = [
-    ref: SmartRefType<HTMLElement>,
-    trackRef: SmartRefType<HTMLElement>
+    ref: SimpleElementType<HTMLElement>,
+    trackRef: SimpleElementType<HTMLElement>
 ];
 type FunReturnType = Pick<ReturnType<typeof CAROUSEL_ANIM>, 'getTrackInitStyle' | 'getObjInitStyle'> & {
     showEl: (el: number | HTMLElement) => void;

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

@@ -1,15 +1,62 @@
-import { CSSProperties } from 'react';
-import { useSimpleRefElementWork } from '..';
-type RefType = Parameters<typeof useSimpleRefElementWork>['0'];
-type OptionsType = {
-    initState?: 'open' | 'hide';
+import { default as React } from 'react';
+export type CollapseState = 'open' | 'close';
+type PropsType<W extends HTMLElement, C extends HTMLElement> = {
+    initElState?: CollapseState;
+    wrapperRef: React.RefObject<W>;
+    contentRef: React.RefObject<C>;
 };
-type PropsType = [ref?: RefType, options?: OptionsType];
-export declare function useCollapsible(...args: PropsType): {
-    isOpen: boolean;
+/**
+ * Хук React для создания сворачиваемых/разворачиваемых UI элементов с GSAP анимациями.
+ *
+ * @template W - Тип HTML элемента обёртки (контейнер, высота которого изменяется)
+ * @template C - Тип HTML элемента контента (внутреннее содержимое, которое сворачивается/разворачивается)
+ *
+ * @param {Object} props - Параметры хука
+ * @param {CollapseState} [props.initElState='open'] - Начальное состояние элемента ('open' или 'close')
+ * @param {React.RefObject<W>} props.wrapperRef - Ref объект для элемента обёртки
+ * @param {React.RefObject<C>} props.contentRef - Ref объект для элемента контента
+ *
+ * @returns {Object} Объект интерфейса хука
+ * @returns {CollapseState} returns.elState - Текущее состояние ('open' или 'close') - реактивное значение для рендеринга
+ * @returns {Function} returns.getElState - Функция получения последнего состояния - используйте в коллбэках для избежания stale closure
+ * @returns {Function} returns.open - Открывает элемент с анимацией
+ * @returns {Function} returns.close - Закрывает элемент с анимацией
+ * @returns {Function} returns.toggle - Переключает между состояниями открыто/закрыто
+ *
+ * @example
+ * ```tsx
+ * const wrapperRef = useRef<HTMLDivElement>(null);
+ * const contentRef = useRef<HTMLDivElement>(null);
+ *
+ * const { elState, toggle } = useCollapsible({
+ *   initElState: 'close',
+ *   wrapperRef,
+ *   contentRef
+ * });
+ *
+ * return (
+ *   <div>
+ *     <button onClick={toggle}>Переключить</button>
+ *     <div ref={wrapperRef}>
+ *       <div ref={contentRef}>
+ *         Сворачиваемый контент здесь
+ *       </div>
+ *     </div>
+ *   </div>
+ * );
+ * ```
+ *
+ * @remarks
+ * - Автоматически обрабатывает изменение размера контента через ResizeObserver в открытом состоянии
+ * - Использует GSAP для плавных анимаций с адаптивной длительностью на основе высоты контента
+ * - Элемент обёртки должен иметь overflow: hidden для предотвращения видимости контента при сворачивании
+ * - Ref объекты должны быть созданы через useRef перед вызовом хука
+ */
+export declare function useCollapsible<W extends HTMLElement, C extends HTMLElement>(props: PropsType<W, C>): {
+    elState: CollapseState;
+    getElState: () => CollapseState;
     open: () => void;
-    hide: () => void;
+    close: () => void;
     toggle: () => void;
-    getInitStyle: () => CSSProperties;
 };
 export {};

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

@@ -1,5 +1,5 @@
-import { useSimpleRefElementWork } from '..';
-type RefType = Parameters<typeof useSimpleRefElementWork>['0'];
+import { useSimpleElement } from '..';
+type RefType = Parameters<typeof useSimpleElement>['0'];
 type OptionsType = {
     xSpeed?: number;
 };

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

@@ -1,10 +1,10 @@
 import { CSSProperties } from 'react';
 import { useSmartPlacementResolver } from '../placement/useSmartPlacementResolver';
 import { MODAL_ANIMATIONS } from './assets';
-import { SmartRefType } from '..';
+import { SimpleElementType } from '..';
 type UseSmartPlacementResolverOptionsType = Exclude<Parameters<typeof useSmartPlacementResolver>['1'], undefined>;
 type OptionsType<T extends HTMLElement = HTMLElement> = Pick<UseSmartPlacementResolverOptionsType, 'position'> & {
-    targetRef?: SmartRefType<T>;
+    targetRef?: SimpleElementType<T>;
     onViewing?: () => void;
     onHiding?: () => void;
     smartPlacementOptions?: Omit<UseSmartPlacementResolverOptionsType, 'position'>;
@@ -17,7 +17,7 @@ type OptionsType<T extends HTMLElement = HTMLElement> = Pick<UseSmartPlacementRe
     };
     backdropColor?: string;
 };
-type PropsType<T extends HTMLElement = HTMLElement> = [ref: SmartRefType<T>, options?: OptionsType];
+type PropsType<T extends HTMLElement = HTMLElement> = [ref: SimpleElementType<T>, options?: OptionsType];
 type AnimationsTypes = keyof ReturnType<typeof MODAL_ANIMATIONS>;
 /**
  * Хук для анимации модального окна.

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

@@ -1,6 +1,6 @@
-import { SmartRefType, SmartRefListType } from '.';
+import { SimpleElementType, SmartRefListType } from '.';
 type PropsType<T extends HTMLElement> = [
-    ref: SmartRefType<T>,
+    ref: SimpleElementType<T>,
     callbacks?: {
         onMissClick?: () => void;
         onInnerClick?: () => void;

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

@@ -0,0 +1,10 @@
+import { SimpleElementType } from '.';
+type PropsType<T extends HTMLElement> = [
+    obj: SimpleElementType<T>,
+    callback?: (ev: Event) => void
+];
+export declare function useScroll<T extends HTMLElement = HTMLElement>(...args: PropsType<T>): {
+    reinit: () => void;
+    deinit: () => void;
+};
+export {};

package/dist/types/src/lib/dict/index.d.ts

@@ -1,4 +1,3 @@
-export { default as isDict } from './isDict';
 export { default as setDeepValue } from './setDeepValue';
 export * from './getDeepValue';
 export * from './compKeyWays';

package/dist/types/src/lib/html/getScrollableParent.d.ts

@@ -0,0 +1,14 @@
+type PropsType = [
+    obj: HTMLElement
+];
+/**
+ * Находит первый родительский элемент, который можно прокручивать
+ *
+ * @param {HTMLElement} obj - HTML-элемент, для которого ищется прокручиваемый родитель
+ * @returns {HTMLElement | undefined} Прокручиваемый родительский элемент или undefined
+ *
+ * @remarks
+ * Максимальная глубина поиска: {@link MAX_DEEP}
+ */
+export declare function getScrollableParent(...args: PropsType): HTMLElement | undefined;
+export {};

package/dist/types/src/lib/html/index.d.ts

@@ -0,0 +1,2 @@
+export * from './getScrollableParent';
+export * from './isScrallableElement';

package/dist/types/src/lib/html/isScrallableElement.d.ts

@@ -0,0 +1,10 @@
+type PropsType = [
+    obj: HTMLElement
+];
+/** Проверяет HTML-элемент на возможность прокрутки по ширине */
+export declare function isScrollableWidthElement(...args: PropsType): boolean;
+/** Проверяет HTML-элемент на возможность прокрутки по высоте */
+export declare function isScrollableHeightElement(...args: PropsType): boolean;
+/** Проверяет HTML-элемент на возможность прокрутки по высоте или ширине */
+export declare function isScrollableElement(...args: PropsType): boolean;
+export {};

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

@@ -4,4 +4,5 @@ export * from './reactComponents';
 export * from './time';
 export * from './animation';
 export * from './searchParams';
-export * from './tsCheck';
+export * from './tsAsserts';
+export * from './html';

package/dist/types/src/lib/reactComponents/index.d.ts

@@ -1,3 +1 @@
-export { default as handleScrollEnd } from './handleScrollEnd';
-export { default as isCustomComponent } from './isCustomComponent';
-export * from './getCenterElementAttribute';
+export * from './isCustomComponent';

package/dist/types/src/lib/reactComponents/isCustomComponent.d.ts

@@ -1 +1 @@
-export default function isCustomComponent(element: React.ReactElement): boolean;
+export declare function isCustomComponent(element: React.ReactElement): boolean;

package/dist/types/src/lib/searchParams/toUrlSearchParams.d.ts

@@ -1,5 +1,6 @@
 type BaseFieldType = string | number | boolean | null;
 type ObjParamsType = Record<string, BaseFieldType | Array<BaseFieldType> | undefined>;
+/** @deprecated */
 export declare function toURLSearchParams(params: ObjParamsType | string): URLSearchParams;
 type ClearObjParamsType = Record<string, Array<string> | string>;
 export declare function toObjURLSearchParamsObj(search: string | URLSearchParams): ClearObjParamsType;

package/dist/types/src/lib/time/saveFormatDate.d.ts

@@ -32,12 +32,15 @@ type SaveFormatDateOptionsBaseType = {
      * */
     errorNull?: boolean;
 };
+/** @deprecated */
 export declare function saveFormatDate(date: string, options: SaveFormatDateOptionsBaseType & {
     errorNull?: false;
 }): string;
+/** @deprecated */
 export declare function saveFormatDate(date: Date, options: SaveFormatDateOptionsBaseType & {
     errorNull?: false;
 }): Date | string;
+/** @deprecated */
 export declare function saveFormatDate(date: string | Date, options: SaveFormatDateOptionsBaseType & {
     errorNull: true;
 }): string | null;

package/dist/types/src/lib/time/saveParseDate.d.ts

@@ -21,5 +21,6 @@ type SaveParseDateOptionsType = {
     fromTimeZone?: string;
     locale?: Pick<Locale, "options" | "formatLong" | "match">;
 };
+/** @deprecated */
 export declare function saveParseDate(date: string, { from, locale, fromTimeZone }: SaveParseDateOptionsType): Date | null;
 export {};

package/dist/types/src/lib/time/startOfDayUTC.d.ts

@@ -2,5 +2,6 @@
  * Функция возвращает старт дня по UTC.
  *
  * Она игнорит часовой пояс, то есть она будет искать время 00:00:00 не от вашего часового пояса, а от UTC.
+ * @deprecated
  * */
 export declare function startOfDayUTC(date: Date | string): Date;

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

@@ -15,6 +15,9 @@ export type IsTuple<T> = T extends readonly any[] ? number extends T['length'] ?
 export type NegativeBoolean<T> = T extends true ? false : true;
 export type NotTuple<T> = NegativeBoolean<IsTuple<T>>;
 export type BuildTuple<N extends number, T extends any[] = []> = T['length'] extends N ? T : BuildTuple<N, [...T, N]>;
+export type PartialAsNull<T> = (IsObject<T> extends true ? IsArray<T> extends true ? T : {
+    [K in keyof T]: T[K] | null;
+} : T);
 export type Nullable<T> = null | (IsObject<T> extends true ? IsArray<T> extends true ? T : {
     [K in keyof T]: T[K] | null;
 } : T);

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

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

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

@@ -0,0 +1,16 @@
+import { CollapseState } from '../../../hooks';
+type PropsType = [
+    onUpdateState?: (state: CollapseState) => void
+];
+export declare function useCollapse<WEl extends HTMLElement, CEl extends HTMLElement>(...args: PropsType): {
+    actions: {
+        elState: CollapseState;
+        getElState: () => CollapseState;
+        open: () => void;
+        close: () => void;
+        toggle: () => void;
+    };
+    wrapperRef: import('react').MutableRefObject<WEl | null>;
+    contentRef: import('react').MutableRefObject<CEl | null>;
+};
+export {};

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

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

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

@@ -0,0 +1,58 @@
+import { default as React, CSSProperties, ElementType } from 'react';
+import { AsProps } from '../../../types';
+import { CollapseState, useCollapsible } from '../../../hooks';
+type CollapsibleReturnType = ReturnType<typeof useCollapsible>;
+type PropsType<C extends ElementType, W extends ElementType> = AsProps<C, {
+    wrapperAs?: W;
+    wrapperClassName?: string;
+    wrapperStyle?: CSSProperties;
+    onUpdateState?: (state: CollapseState) => void;
+}>;
+type RefType = CollapsibleReturnType;
+/**
+ * Collapse — полиморфный JSX-компонент, являющийся компонентной реализацией хука `useCollapsible`.
+ *
+ * Компонент рендерит “обёртку” (`wrapperAs`) и “контент” (`as`), создаёт `ref`-ы для обоих элементов
+ * и подключает к ним логику сворачивания/разворачивания (анимации/изменение размеров) через `useCollapsible`.
+ *
+ * @template C Тип элемента/компонента контента (prop `as`).
+ * @template W Тип элемента/компонента обёртки (prop `wrapperAs`).
+ *
+ * @param {object} props Props компонента.
+ * @param {C} [props.as='div'] Элемент/компонент для контента. В него пробрасываются остальные props.
+ * @param {W} [props.wrapperAs='div'] Элемент/компонент для обёртки (контейнер с изменяемой высотой).
+ * @param {string} [props.wrapperClassName] `className` для обёртки.
+ * @param {import('react').CSSProperties} [props.wrapperStyle] `style` для обёртки (будет объединён с `{ overflow: 'hidden' }`).
+ * @param {(state: import('@/hooks').CollapseState) => void} [props.onUpdateState]
+ * Коллбэк, вызываемый при смене состояния (`'open' | 'close'`).
+ *
+ * @returns {import('react').ReactElement | null} React-элемент или `null`.
+ *
+ * @ref
+ * Ref (imperative API) возвращает объект действий из `useCollapsible`, например:
+ * `open()`, `close()`, `toggle()`, `elState`, `getElState()` и связанные методы.
+ *
+ * @remarks
+ * - `as` и `wrapperAs` должны поддерживать `ref` на `HTMLElement` (обычно intrinsic теги или компоненты с `forwardRef`).
+ * - Обёртке принудительно задаётся `overflow: hidden` (плюс ваш `wrapperStyle`) для корректного визуального коллапса.
+ *
+ * @example
+ * ```tsx
+ * const apiRef = useRef<CollapsibleReturnType>(null);
+ *
+ * <Collapse
+ *   wrapperAs="div"
+ *   as="div"
+ *   wrapperClassName="my-wrapper"
+ *   wrapperStyle={{ willChange: 'height' }}
+ *   onUpdateState={(s) => console.log('state:', s)}
+ *   ref={apiRef}
+ * >
+ *   Контент
+ * </Collapse>
+ *
+ * // apiRef.current?.toggle();
+ * ```
+ */
+export declare const Collapse: <C extends ElementType, W extends ElementType, WEl extends HTMLElement = React.ElementRef<W> extends HTMLElement ? React.ElementRef<W> : never, CEl extends HTMLElement = React.ElementRef<C> extends HTMLElement ? React.ElementRef<C> : never>(props: PropsType<C, W> & React.RefAttributes<RefType>) => React.ReactElement | null;
+export {};

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

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

package/dist/types/src/ui/DropdownV2/animations/check.d.ts

@@ -0,0 +1,10 @@
+type PropsType = [
+    obj: HTMLElement | SVGElement,
+    timeline: gsap.core.Timeline
+];
+type FunReturnType = {
+    appear: () => gsap.core.Timeline;
+    disappear: () => gsap.core.Timeline;
+};
+export declare function CHECK_APPEARANCE_ANIM(...args: PropsType): FunReturnType;
+export {};

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

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

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

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

package/package.json

@@ -11,7 +11,7 @@
     "react-components",
     "ui-kit"
   ],
-  "version": "1.0.6",
+  "version": "1.0.8",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",

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

@@ -1,20 +0,0 @@
-import { RefObject } from 'react';
-export type SmartRefType<T extends HTMLElement> = RefObject<T | null> | T | null | undefined | (() => T | null | undefined);
-type SimpleRefElementWorkPropsType<T extends HTMLElement> = [
-    ref?: SmartRefType<T>
-];
-type SimpleRefElementWorkFunReturnType<T extends HTMLElement> = [
-    getObj: () => T | null,
-    _getObj: (item: SmartRefType<T>) => T | null
-];
-export declare function useSimpleRefElementWork<T extends HTMLElement = HTMLElement>(...args: SimpleRefElementWorkPropsType<T>): SimpleRefElementWorkFunReturnType<T>;
-export type SmartRefListType<T extends HTMLElement> = SmartRefType<T> | Array<SmartRefType<T>>;
-type SimpleRefListElementWorkPropsType<T extends HTMLElement> = [
-    ref?: SmartRefListType<T>
-];
-type SimpleRefListElementWorkFunReturnType<T extends HTMLElement> = [
-    getObjects: () => Array<T | null>,
-    _getObjects: (item: SmartRefListType<T>) => Array<T | null>
-];
-export declare function useSimpleRefListElementWork<T extends HTMLElement = HTMLElement>(...args: SimpleRefListElementWorkPropsType<T>): SimpleRefListElementWorkFunReturnType<T>;
-export {};

package/dist/types/src/lib/dict/isDict.d.ts

@@ -1 +0,0 @@
-export default function isDict(variable: any): boolean;

package/dist/types/src/lib/reactComponents/getCenterElementAttribute.d.ts

@@ -1,6 +0,0 @@
-type FunContainerPropsType = HTMLElement | null | undefined;
-type FunOptionPropsType = {
-    key?: string;
-};
-export declare function getCenterElementAttribute(container: FunContainerPropsType, options?: FunOptionPropsType | undefined): string | null;
-export {};

package/dist/types/src/lib/reactComponents/handleScrollEnd.d.ts

@@ -1,2 +0,0 @@
-import { default as React } from 'react';
-export default function handleScrollEnd(e: React.UIEvent<HTMLDivElement>, callback: (e: React.UIEvent<HTMLDivElement>) => void): void;