indicator-ui 1.0.50 → 1.1.0

package/dist/styles/mixins/index.scss

@@ -6,3 +6,4 @@
 @forward "changeSvg";
 @forward "themes";
 @forward "utils";
+@forward "property-color";

package/dist/styles/mixins/property-color.scss

@@ -0,0 +1,21 @@
+@mixin property-color(
+  $component,
+  $prefix: null,
+  $property,
+  $name: null,
+  $color,
+) {
+  $css-prefix: null;
+  @if ($prefix != null) {
+    $css-prefix: '-#{$prefix}-';
+  } @else {
+    $css-prefix: '-'
+  }
+  @if ($name == null) {
+    $name: $property
+  }
+
+  & {
+    #{$property}: var(--ui-#{$component}#{$css-prefix}#{$name}, $color);
+  }
+}

package/dist/styles/mixins/utils.scss

@@ -9,7 +9,7 @@
   }
 }
 
-@mixin hover {
+@mixin hoverIsAvailable {
   @media (hover: hover) {
     @content;
   }

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

@@ -1 +1,2 @@
 export * from './useInfinityFeed';
+export type { InfinityFeedState } from './state';

package/dist/types/src/hooks/feed/infinityFeed/hooks/state/useFeed.d.ts

@@ -1,13 +1,13 @@
 import { useAsyncState } from '../../../..';
-export type FeedState<T> = Array<T>;
+export type InfinityFeedState<T> = Array<T>;
 type PropsType<T> = {
-    feedState: ReturnType<typeof useAsyncState<FeedState<T>>>;
+    feedState: ReturnType<typeof useAsyncState<InfinityFeedState<T>>>;
 };
 export declare function useFeed<T>(props: PropsType<T>): {
     setFeed: {
-        asyncEffect: (value: import('react').SetStateAction<FeedState<T>>) => Promise<FeedState<T>>;
-        asyncLayout: (value: import('react').SetStateAction<FeedState<T>>) => Promise<FeedState<T>>;
-        asyncDom: (value: import('react').SetStateAction<FeedState<T>>) => Promise<FeedState<T>>;
+        asyncEffect: (value: import('react').SetStateAction<InfinityFeedState<T>>) => Promise<InfinityFeedState<T>>;
+        asyncLayout: (value: import('react').SetStateAction<InfinityFeedState<T>>) => Promise<InfinityFeedState<T>>;
+        asyncDom: (value: import('react').SetStateAction<InfinityFeedState<T>>) => Promise<InfinityFeedState<T>>;
     };
 };
 export {};

package/dist/types/src/hooks/feed/infinityFeed/hooks/state/useFeedManager.d.ts

@@ -1,19 +1,21 @@
-import { useFeed, FeedState } from './useFeed';
+import { useFeed, InfinityFeedState } from './useFeed';
 type PropsType<T> = Pick<ReturnType<typeof useFeed<T>>, 'setFeed'> & {
+    /** Получение элементов вокруг `instance`. Возвращаемое значение - [..., instance, ...] */
+    getElementsAround: (instance: T, prev: InfinityFeedState<T>) => InfinityFeedState<T>;
     /** Получение элементов перед `instance`. Возвращаемое значение - [firstElementOfNewList, instance) */
-    getElementsBefore: (instance: T, prev: FeedState<T>) => FeedState<T>;
+    getElementsBefore: (instance: T, prev: InfinityFeedState<T>) => InfinityFeedState<T>;
     /** Получение элементов после `instance`. Возвращаемое значение - (instance, lastElementOfNewList) */
-    getElementsAfter: (instance: T, prev: FeedState<T>) => FeedState<T>;
+    getElementsAfter: (instance: T, prev: InfinityFeedState<T>) => InfinityFeedState<T>;
     /** Удаление элементов перед `lastElement`. Возвращаемое значение - [..., someElementBeforeLastElement] */
-    removeElementsBefore: (lastElement: T, prev: FeedState<T>) => FeedState<T>;
-    /** Удаление элементов перед `firstElement`. Возвращаемое значение - [someElementAfterFirstElement, ...] */
-    removeElementsAfter: (firstElement: T, prev: FeedState<T>) => FeedState<T>;
+    removeElementsBefore: (lastElement: T, prev: InfinityFeedState<T>) => InfinityFeedState<T>;
+    /** Удаление элементов после `firstElement`. Возвращаемое значение - [someElementAfterFirstElement, ...] */
+    removeElementsAfter: (firstElement: T, prev: InfinityFeedState<T>) => InfinityFeedState<T>;
 };
 export declare function useFeedManager<T>(props: PropsType<T>): {
-    push: () => Promise<FeedState<T>>;
-    unshift: () => Promise<FeedState<T>>;
-    shift: () => Promise<FeedState<T>>;
-    pop: () => Promise<FeedState<T>>;
-    set: (target: T) => Promise<FeedState<T>>;
+    push: () => Promise<InfinityFeedState<T>>;
+    unshift: () => Promise<InfinityFeedState<T>>;
+    shift: () => Promise<InfinityFeedState<T>>;
+    pop: () => Promise<InfinityFeedState<T>>;
+    set: (target: T) => Promise<InfinityFeedState<T>>;
 };
 export {};

package/dist/types/src/hooks/feed/infinityFeed/hooks/useInfinityFeed.d.ts

@@ -3,22 +3,12 @@ import { useScrollManager } from './useScrollManager';
 type UseFeedProps<T> = Parameters<typeof useFeed<T>>[number];
 type UseFeedManagerProps<T> = Parameters<typeof useFeedManager<T>>[number];
 type UseScrollManagerProps<T, F extends HTMLElement> = Parameters<typeof useScrollManager<T, F>>[number];
-type PropsType<T, F extends HTMLElement> = Pick<UseFeedProps<T>, 'feedState'> & Pick<UseFeedManagerProps<T>, 'getElementsAfter' | 'getElementsBefore' | 'removeElementsAfter' | 'removeElementsBefore'> & Pick<UseScrollManagerProps<T, F>, 'feedRef' | 'getElementByItem'>;
+type PropsType<T, F extends HTMLElement> = Pick<UseFeedProps<T>, 'feedState'> & Pick<UseFeedManagerProps<T>, "getElementsAround" | 'getElementsAfter' | 'getElementsBefore' | 'removeElementsAfter' | 'removeElementsBefore'> & Pick<UseScrollManagerProps<T, F>, 'feedRef' | 'getElementByItem'>;
 export declare function useInfinityFeed<T, F extends HTMLElement>(props: PropsType<T, F>): {
-    onScrollToStart: (ev: import('../../..').ScrollInfoEvent<HTMLElement> & {
-        origin: Event;
-        commitScroll: () => import('../../..').ScrollAnchorCommit;
-        revertScroll: (commit: import('../../..').ScrollAnchorCommit) => import('../../..').ScrollAnchorCommit;
-    }) => void | undefined;
-    onScrollToEnd: (ev: import('../../..').ScrollInfoEvent<HTMLElement> & {
-        origin: Event;
-        commitScroll: () => import('../../..').ScrollAnchorCommit;
-        revertScroll: (commit: import('../../..').ScrollAnchorCommit) => import('../../..').ScrollAnchorCommit;
-    }) => void | undefined;
-    scrollToElement: (instance: T, options?: {
-        offset?: number;
-        block?: ScrollLogicalPosition;
+    onScrollToStart: (event: import('../../..').ScrollHandlerEvent<HTMLElement>) => Promise<void> | undefined;
+    onScrollToEnd: (event: import('../../..').ScrollHandlerEvent<HTMLElement>) => Promise<void> | undefined;
+    scrollToElement: (instance: T, options?: (import('../../..').ScrollTopToElementOptions & {
         behavior?: ScrollBehavior;
-    } | undefined) => Promise<void> | undefined;
+    }) | undefined) => Promise<void> | undefined;
 };
 export {};

package/dist/types/src/hooks/feed/infinityFeed/hooks/useScrollManager.d.ts

@@ -1,8 +1,6 @@
-import { ElementRefAdapter } from '../../..';
+import { ElementRefAdapter, ScrollTopToElementOptions } from '../../..';
 import { useFeedManager } from './state';
-type ScrollToOptions = {
-    offset?: number;
-    block?: ScrollLogicalPosition;
+type ScrollToOptions = ScrollTopToElementOptions & {
     behavior?: ScrollBehavior;
 };
 type PropsType<T, F extends HTMLElement> = Pick<ReturnType<typeof useFeedManager<T>>, 'pop' | 'push' | 'shift' | 'unshift' | 'set'> & {
@@ -10,16 +8,8 @@ type PropsType<T, F extends HTMLElement> = Pick<ReturnType<typeof useFeedManager
     feedRef: ElementRefAdapter<F>;
 };
 export declare function useScrollManager<T, F extends HTMLElement>(props: PropsType<T, F>): {
-    onScrollToStart: (ev: import('../../..').ScrollInfoEvent<HTMLElement> & {
-        origin: Event;
-        commitScroll: () => import('../../..').ScrollAnchorCommit;
-        revertScroll: (commit: import('../../..').ScrollAnchorCommit) => import('../../..').ScrollAnchorCommit;
-    }) => void | undefined;
-    onScrollToEnd: (ev: import('../../..').ScrollInfoEvent<HTMLElement> & {
-        origin: Event;
-        commitScroll: () => import('../../..').ScrollAnchorCommit;
-        revertScroll: (commit: import('../../..').ScrollAnchorCommit) => import('../../..').ScrollAnchorCommit;
-    }) => void | undefined;
+    onScrollToStart: (event: import('../../..').ScrollHandlerEvent<HTMLElement>) => Promise<void> | undefined;
+    onScrollToEnd: (event: import('../../..').ScrollHandlerEvent<HTMLElement>) => Promise<void> | undefined;
     scrollToElement: (instance: T, options?: ScrollToOptions | undefined) => Promise<void> | undefined;
 };
 export {};

package/dist/types/src/hooks/feed/wheel/classes/index.d.ts

@@ -1,4 +1,4 @@
-export * from './parabola';
-export * from './baseFunction';
+export * from './wheelLyingParabola';
+export * from './wheelBaseFunction';
 export * from './coordinateSystemTransformer';
 export * from './normalizeAngle';

package/dist/types/src/hooks/feed/wheel/classes/wheelBaseFunction.d.ts

@@ -0,0 +1,5 @@
+import { vec3 } from 'gl-matrix';
+export declare abstract class WheelBaseFunction {
+    abstract calcPointByXY(x: number, y: number): vec3;
+    abstract calcAngleToAxisZ(point: vec3): number;
+}

package/dist/types/src/hooks/feed/wheel/classes/wheelLyingParabola.d.ts

@@ -0,0 +1,10 @@
+import { vec3 } from 'gl-matrix';
+import { WheelBaseFunction } from './wheelBaseFunction';
+export declare class WheelLyingParabola extends WheelBaseFunction {
+    private a;
+    private b;
+    private c;
+    constructor(a?: number, b?: number, c?: number);
+    calcPointByXY(x: number, y: number): vec3;
+    calcAngleToAxisZ(point: vec3): number;
+}

package/dist/types/src/hooks/feed/wheel/hooks/useParabolicVerticalFeed.d.ts

@@ -1,5 +1,6 @@
 import { CSSProperties } from 'react';
-import { Parabola } from '../classes';
-export declare function useParabolicVerticalFeed(parabola: Parabola): {
-    getWheelElementsStyle: (targetElement: HTMLElement, feedElement: HTMLElement) => CSSProperties;
+import { vec3 } from 'gl-matrix';
+import { WheelLyingParabola } from '../classes';
+export declare function useParabolicVerticalFeed(): {
+    getWheelElementsStyle: (elementVectorInFeedCoordinate: vec3, parabola: WheelLyingParabola) => CSSProperties;
 };

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

@@ -3,8 +3,6 @@ export * from './useFormData';
 export * from './useDebouncedAccumulator';
 export * from './useDeepCompareEffect';
 export * from './useElementFixedOffset';
-export * from './useSyncedStateRef';
-export * from './useAsyncState';
 export * from './useResettableTimeout';
 export * from './useDebouncedInvoker';
 export * from './useDidUpdateEffect';

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

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

package/dist/types/src/hooks/scroll/hooks/elementScrollPosition/hooks/useElementScrollPosition.d.ts

@@ -0,0 +1,18 @@
+export type ScrollTopToElementOptions = {
+    offset?: number;
+    block?: ScrollLogicalPosition;
+};
+export type ElementScrollPosition = {
+    scrollTop: number;
+    scrollLeft: number;
+    deltaScrollTop: number;
+    deltaScrollLeft: number;
+    clientWidth: number;
+    clientHeight: number;
+    offsetWidth: number;
+    offsetHeight: number;
+};
+export declare function useElementScrollPosition(): {
+    getElementScrollPosition: <T extends HTMLElement>(element: T) => ElementScrollPosition;
+    calcScrollTopToElement: (element: HTMLElement, container: HTMLElement, options?: ScrollTopToElementOptions) => number;
+};

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

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

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

@@ -0,0 +1,8 @@
+export declare function getParentsOffsets(element: HTMLElement): {
+    offsetTop: number;
+    offsetLeft: number;
+};
+export declare function getElementViewportPosition(element: HTMLElement): {
+    top: number;
+    left: number;
+};

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

@@ -1,4 +1,8 @@
 export * from './useScrollAnchor';
 export * from './useScrollInfo';
+export * from './useScrollOffsetState';
 export * from './scrollHandler';
-export * from './useScrollSync';
+export * from './scrollSync';
+export * from './scrollToAsync';
+export * from './elementScrollPosition';
+export * from './scrollMaster';

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

@@ -3,14 +3,14 @@ import { ScrollAnchorCommit } from '../../types';
 import { useScrollAnchor } from '../useScrollAnchor';
 import { useScrollInfo } from '../useScrollInfo';
 import { useScrollMinDelta } from './useScrollMinDelta';
-type ScrollEvent<T extends HTMLElement> = ScrollInfoEvent<T> & {
+export type ScrollHandlerEvent<T extends HTMLElement> = ScrollInfoEvent<T> & {
     origin: Event;
     commitScroll: () => ScrollAnchorCommit;
     revertScroll: (commit: ScrollAnchorCommit) => ScrollAnchorCommit;
 };
 type Options<T extends HTMLElement> = Parameters<typeof useScrollInfo<T>>[number] & Parameters<typeof useScrollAnchor<T>>[number] & Parameters<typeof useScrollMinDelta>[number];
-type Callback<T extends HTMLElement> = (ev: ScrollEvent<T>) => void;
-export declare function useScrollHandler<T extends HTMLElement>(ref: ElementRefAdapter<T>, callback: Callback<T>, options?: Options<T>): {
+export type ScrollHandlerCallback<T extends HTMLElement> = (ev: ScrollHandlerEvent<T>) => void;
+export declare function useScrollHandler<T extends HTMLElement>(ref: ElementRefAdapter<T>, callback: ScrollHandlerCallback<T>, options?: Options<T>): {
     getInfo: () => ScrollInfoEvent<T>;
     getObj: <T_1 extends HTMLElement>(instance: ElementRefAdapter<T_1>) => T_1 | null;
     commitScroll: () => ScrollAnchorCommit;

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

@@ -0,0 +1,4 @@
+export * from './useUserScrollMaster';
+export * from './useTouchScroll';
+export * from './useWheelScroll';
+export * from './useKeyboardScroll';

package/dist/types/src/hooks/scroll/hooks/scrollMaster/hooks/useKeyboardScroll.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { MasterScrollCallback } from '../types';
+export type KeyboardScrollOptions = {
+    step?: number;
+    pageStep?: number;
+};
+export declare function useKeyboardScroll(ref: React.RefObject<HTMLElement>, callback: MasterScrollCallback, options?: KeyboardScrollOptions): void;

package/dist/types/src/hooks/scroll/hooks/scrollMaster/hooks/useTouchScroll.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { MasterScrollCallback } from '../types';
+export declare function useTouchScroll(ref: React.RefObject<HTMLElement>, callback: MasterScrollCallback): void;

package/dist/types/src/hooks/scroll/hooks/scrollMaster/hooks/useUserScrollMaster.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { MasterScrollCallback } from '../types';
+import { KeyboardScrollOptions } from './useKeyboardScroll';
+export type UserScrollMasterOptions = KeyboardScrollOptions;
+export declare function useUserScrollMaster<T extends HTMLElement>(ref: React.RefObject<T>, callback: MasterScrollCallback, options?: UserScrollMasterOptions): void;

package/dist/types/src/hooks/scroll/hooks/scrollMaster/hooks/useWheelScroll.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { MasterScrollCallback } from '../types';
+export declare function useWheelScroll(ref: React.RefObject<HTMLElement>, callback: MasterScrollCallback): void;

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

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

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

@@ -0,0 +1,20 @@
+type WheelUserScrollEvent = {
+    type: 'wheel';
+    event: WheelEvent;
+};
+type TouchUserScrollEvent = {
+    type: 'touch';
+    event: TouchEvent;
+};
+type KeyboardUserScrollEvent = {
+    type: 'keyboard';
+    event: KeyboardEvent;
+};
+export type OriginScrollEvent = WheelUserScrollEvent | TouchUserScrollEvent | KeyboardUserScrollEvent;
+export type MasterScrollEvent = {
+    deltaX: number;
+    deltaY: number;
+    origin: OriginScrollEvent;
+};
+export type MasterScrollCallback = (event: MasterScrollEvent) => void;
+export {};

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

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

package/dist/types/src/hooks/scroll/hooks/scrollSync/classes/scrollRatio.d.ts

@@ -0,0 +1,6 @@
+export declare class ScrollRatio {
+    private readonly absScrollOffset;
+    private calcRatio;
+    constructor(scrollOffset: number, scrollSize: number, clientSize: number);
+    calcScrollOffset(scrollSize: number, clientSize: number): number;
+}

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

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

package/dist/types/src/hooks/scroll/hooks/scrollSync/hooks/useScrollChannel.d.ts

@@ -0,0 +1,9 @@
+type ScrollChannel = HTMLElement;
+export declare function useScrollChannel(): {
+    stopChannel: () => void;
+    startScrollChannel: (channel: ScrollChannel) => void;
+    isChannelSource: (item: ScrollChannel) => boolean;
+    isChannelStart: () => boolean;
+    stopChannelInstant: () => void;
+};
+export {};

package/dist/types/src/hooks/scroll/hooks/scrollSync/hooks/useScrollListener.d.ts

@@ -0,0 +1,5 @@
+import { ElementRefAdapter } from '../../../..';
+type ElementsRefs = Array<ElementRefAdapter<HTMLElement>>;
+export type ScrollCallback = (ev: Event) => void;
+export declare function useScrollListener(elements: ElementsRefs, callback: ScrollCallback): void;
+export {};

package/dist/types/src/hooks/scroll/hooks/scrollSync/hooks/useScrollSync.d.ts

@@ -0,0 +1,9 @@
+import { ElementRefAdapter } from '../../../..';
+type OnScrollCallback = (e: Event) => void;
+type Options = {
+    callback?: OnScrollCallback;
+};
+export declare function useScrollSync(elements: Array<ElementRefAdapter<HTMLElement>>, options?: Options): {
+    scrollTo: (element: HTMLElement, options: ScrollToOptions) => Promise<void>;
+};
+export {};

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

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

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

@@ -0,0 +1 @@
+export declare function assertAbsRatio(absRatio: any): asserts absRatio is number;

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

@@ -0,0 +1,2 @@
+export * from './useAsyncScrollToRef';
+export * from './useAsyncScrollTo';

package/dist/types/src/hooks/scroll/hooks/scrollToAsync/useAsyncScrollTo.d.ts

@@ -0,0 +1 @@
+export declare function useScrollToAsync(): (element: HTMLElement, options: ScrollToOptions) => Promise<void>;

package/dist/types/src/hooks/scroll/hooks/scrollToAsync/useAsyncScrollToRef.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare function useAsyncScrollToRef<T extends HTMLElement>(ref: React.RefObject<T>): (options: ScrollToOptions) => Promise<void>;

package/dist/types/src/hooks/scroll/hooks/scrollToAsync/useRejectTimeouts.d.ts

@@ -0,0 +1,6 @@
+import { ScrollPromiseKey } from './useScrollPromises';
+export declare function useRejectTimeouts(): {
+    clearRejectTimeoutItem: (key: ScrollPromiseKey) => void;
+    clearAllRejectTimeouts: () => void;
+    setRejectTimeout: (key: ScrollPromiseKey, instance: NodeJS.Timeout) => void;
+};

package/dist/types/src/hooks/scroll/hooks/scrollToAsync/useScrollPromises.d.ts

@@ -0,0 +1,10 @@
+export type ScrollPromiseKey = string;
+type PromiseResolver = () => void;
+type PromiseRereject = () => void;
+export declare function useScrollPromises(): {
+    addPromiseResolver: (resolver: PromiseResolver, rejecter: PromiseRereject) => ScrollPromiseKey;
+    getPromiseActions: (key: ScrollPromiseKey) => [PromiseResolver, PromiseRereject] | undefined;
+    removePromiseResolver: (key: ScrollPromiseKey) => void;
+    getAllPromisesKeys: () => string[];
+};
+export {};

package/dist/types/src/hooks/scroll/hooks/scrollToAsync/useScrollTargetInfo.d.ts

@@ -0,0 +1,6 @@
+import { ScrollPromiseKey } from './useScrollPromises';
+export declare function useScrollTargetInfo(): {
+    getScrollTargetInfo: (key: ScrollPromiseKey) => ScrollToOptions | undefined;
+    setScrollTargetInfo: (key: ScrollPromiseKey, info: ScrollToOptions) => void;
+    removeScrollTargetInfo: (key: ScrollPromiseKey) => void;
+};

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

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+type ScrollOffsetState = {
+    scrollTop: number;
+    scrollLeft: number;
+};
+export declare function useScrollOffsetState(ref: React.RefObject<HTMLElement>): readonly [ScrollOffsetState, () => ScrollOffsetState];
+export {};

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

@@ -1,7 +1,7 @@
 import { CSSProperties } from 'react';
+import { SimpleElementType } from '..';
 import { useSmartPlacementResolver } from '../placement/useSmartPlacementResolver';
 import { MODAL_ANIMATIONS } from './assets';
-import { SimpleElementType } from '..';
 type UseSmartPlacementResolverOptionsType = Exclude<Parameters<typeof useSmartPlacementResolver>['1'], undefined>;
 type OptionsType<T extends HTMLElement = HTMLElement> = Pick<UseSmartPlacementResolverOptionsType, 'position'> & {
     targetRef?: SimpleElementType<T>;

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

@@ -4,3 +4,9 @@ export * from './useLockedCallback';
 export * from './useRefAdapter';
 export * from './useStableCallbackInvoke';
 export * from './useIntersectionObserver';
+export * from './useMostVisibleElement';
+export * from './useElementsRefs';
+export * from './useSyncedStateRef';
+export * from './useAsyncState';
+export * from './useMutex';
+export * from './useRequestAnimationFrameAsync';

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

@@ -0,0 +1,12 @@
+type ElementKey = string | number;
+type ElementsRefs<T extends HTMLElement> = Map<ElementKey, T>;
+export declare function useElementsRefs<T extends HTMLElement>(): {
+    addElementRef: (key: ElementKey, element: T) => void;
+    updateElement: (key: ElementKey, element: T | null) => void;
+    removeElementRef: (key: ElementKey) => void;
+    getElementsRefsEntries: () => [ElementKey, T][];
+    getElementsRefs: () => ElementsRefs<T>;
+    getElementRef: (key: ElementKey) => T | undefined;
+    clearNotConnectedElements: () => void;
+};
+export {};

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

@@ -1,5 +1,10 @@
-export declare function useIntersectionObserve(callback: IntersectionObserverCallback, options: IntersectionObserverInit): {
+import { default as React } from 'react';
+type Options = Omit<IntersectionObserverInit, 'root'> & {
+    root?: React.RefObject<HTMLElement>;
+};
+export declare function useIntersectionObserve(callback: IntersectionObserverCallback, options: Options): {
     observe: (target: Element) => void;
     unobserve: (target: Element) => void;
     reinitObserver: () => void;
 };
+export {};

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

@@ -0,0 +1,15 @@
+import { useIntersectionObserve } from './useIntersectionObserver';
+type VisibleData = {
+    area: number;
+    ratio: number;
+};
+type ElementVisibleInfo<T extends HTMLElement> = Map<T, VisibleData>;
+type MostVisibleElement<T extends HTMLElement> = [element: T, data: VisibleData, info: ElementVisibleInfo<T>];
+type Options = Parameters<typeof useIntersectionObserve>[1];
+export declare function useMostVisibleElement<T extends HTMLElement>(options: Options): {
+    observe: (target: Element) => void;
+    clearNotConnectedElements: () => void;
+    mostVisibleElement: MostVisibleElement<T> | undefined;
+    getMostVisibleElement: () => MostVisibleElement<T> | undefined;
+};
+export {};

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

@@ -0,0 +1,5 @@
+export declare function useMutex(): {
+    lock: () => Promise<void>;
+    unlock: () => void;
+    isLocked: () => boolean;
+};

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

@@ -0,0 +1 @@
+export declare function useRequestAnimationFrameAsync(): (callback: FrameRequestCallback) => Promise<void>;

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

@@ -0,0 +1 @@
+export declare function assertHtmlElement(element: any, elementName?: string): asserts element is HTMLElement;

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

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

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

@@ -6,3 +6,4 @@ export * from './animation';
 export * from './searchParams';
 export * from './tsAsserts';
 export * from './html';
+export * from './asserts';

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

@@ -1,2 +1,4 @@
+/** @deprecated */
 export declare function isObject<T>(value: T): value is T & object;
+/** @deprecated */
 export declare function isPromise<T>(value: T): boolean;

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

@@ -2,5 +2,6 @@ import { default as React } from 'react';
 import { useDateTimePicker } from '../hooks';
 type DateType = Exclude<Parameters<typeof useDateTimePicker>[number]['type'], undefined>;
 type PropsType<T extends DateType> = Parameters<typeof useDateTimePicker<T>>[number];
+/** @deprecated используйте {@link DatePickerV2}, {@link DateTimePickerV2}, {@link DateRangePickerV2} */
 export declare const DateTimePicker: <T extends DateType>(props: PropsType<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null;
 export {};

package/dist/types/src/ui/InputFields/DateTimeField/ui/DateField.d.ts

@@ -1,2 +1,2 @@
 import { DateFieldPropsType } from '../../..';
-export declare function DateField({ value, onChange, dateFormat, outFormat, additionStyle, datePlaceholder, iconDate, textDate, clearButton, isError, disabled, onFocus, onBlur, width, position, theme, ...props }: DateFieldPropsType): import("react/jsx-runtime").JSX.Element;
+export declare function DateField({ value, onChange, dateFormat, outFormat, datePlaceholder, iconDate, textDate, isError, disabled, onBlur, }: DateFieldPropsType): import("react/jsx-runtime").JSX.Element;

package/dist/types/src/ui/InputFields/DateTimeField/ui/DateTimeField.d.ts

@@ -1,2 +1,2 @@
 import { DateTimeFieldPropsType } from '../types';
-export declare function DateTimeField({ value, onChange, dateFormat, timeFormat, outFormat, additionStyle, datePlaceholder, timePlaceholder, iconDate, iconTime, textDate, textTime, clearButton, isError, disabled, onFocus, onBlur, width, position, theme, ...props }: DateTimeFieldPropsType): import("react/jsx-runtime").JSX.Element;
+export declare function DateTimeField({ value, onChange, dateFormat, timeFormat, outFormat, datePlaceholder, timePlaceholder, iconDate, iconTime, textDate, textTime, isError, disabled, onBlur, }: DateTimeFieldPropsType): import("react/jsx-runtime").JSX.Element;

package/dist/types/src/ui/InputFields/DateTimeRangeField/ui/DateRangeField.d.ts

@@ -1,2 +1,2 @@
 import { DateRangeFieldPropsType } from '../types';
-export declare function DateRangeField({ value, onChange, secondPlaceholder, firstPlaceholder, secondIcon, disabled, dateFormat, required, firstIcon, onBlur, firstText, secondText, onFocus, isError, clearButton, width, additionsStyles, position, theme }: DateRangeFieldPropsType): import("react/jsx-runtime").JSX.Element;
+export declare function DateRangeField({ value, onChange, secondPlaceholder, firstPlaceholder, secondIcon, disabled, dateFormat, firstIcon, onBlur, firstText, secondText, isError, }: DateRangeFieldPropsType): import("react/jsx-runtime").JSX.Element;

package/dist/types/src/ui/Toggle/types/ToggleTypes.d.ts

@@ -34,6 +34,9 @@ export type TogglePropsType = {
      * Элемент после text
      * */
     textAfterElement?: AdditionElementType;
+    /**
+     * @deprecated
+     */
     theme?: "light" | "dark";
     size?: React.ComponentProps<typeof ToggleBase>['size'];
 };

package/dist/types/src/ui/datePickersV2/hooks/components/time/index.d.ts

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

package/dist/types/src/ui/datePickersV2/hooks/components/time/useTimePickerTagList.d.ts

@@ -0,0 +1,12 @@
+type Time = string;
+type PropsType = {
+    previewTime?: Time;
+    onChooseTime: (instance: Time) => void;
+};
+export declare function useTimePickerTagList(props: PropsType): {
+    tags: string[];
+    getTimeLabel: (item: Time) => string;
+    onSelectTag: (item: Time) => void;
+    onSelectNow: () => void;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/dateManagers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './useDateManager';
+export * from './useDateRangeManager';
+export * from './useDateTimeManager';

package/dist/types/src/ui/datePickersV2/hooks/dateManagers/useDateInputManager.d.ts

@@ -0,0 +1,13 @@
+type InputSchemeDefault = {
+    [K in string]: unknown;
+};
+type PropsType<InputScheme extends InputSchemeDefault> = {
+    resetOnChange: Record<keyof InputScheme, Array<keyof InputScheme>>;
+};
+export declare function useDateInputManager<_InputScheme extends InputSchemeDefault>(props: PropsType<_InputScheme>): {
+    setInput: <K extends keyof _InputScheme>(key: K, instance: Partial<_InputScheme>[K]) => void;
+    dateInput: Partial<Partial<_InputScheme>>;
+    getDateInput: () => Partial<Partial<_InputScheme>>;
+    clearDateInput: () => void;
+};
+export {};