indicator-ui 1.0.50 → 1.1.0

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

@@ -0,0 +1,19 @@
+type CommitedDate = string | undefined;
+export declare function useDateManager(): {
+    dateInput: Partial<Partial<Partial<{
+        year: number;
+        monthYear: string;
+        dayMonthYear: string;
+    }>>>;
+    setInput: <K extends "year" | "monthYear" | "dayMonthYear">(key: K, instance: Partial<Partial<{
+        year: number;
+        monthYear: string;
+        dayMonthYear: string;
+    }>>[K]) => void;
+    createCommitDate: (prev: CommitedDate) => NonNullable<CommitedDate>;
+    clearDateInput: () => void;
+    initViewYear: number | undefined;
+    initViewMonthYear: string | undefined;
+    initViewDayMonthYear: string | undefined;
+};
+export {};

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

@@ -0,0 +1,8 @@
+import { DateArg } from 'date-fns';
+export declare function useDateManagerUtils(): {
+    setYearInDate: (date: DateArg<Date>, year: number) => string;
+    setMonthYearInDate: (date: DateArg<Date>, monthYear: string) => string;
+    setDayMonthYearInDate: (date: DateArg<Date>, dayMonthYear: string) => string;
+    setHoursInDate: (date: DateArg<Date>, hours: number) => string;
+    setMinutesInDate: (date: DateArg<Date>, minutes: number) => string;
+};

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

@@ -0,0 +1,15 @@
+type DateItem = string;
+type CommitedDate = Array<DateItem> | undefined;
+export declare function useDateRangeManager(): {
+    setInput: <K extends "year" | "monthYear" | "dayMonthYear">(key: K, instance: Partial<Partial<{
+        year: number;
+        monthYear: string;
+        dayMonthYear: string;
+    }>>[K]) => void;
+    createCommitDateRange: (prev: CommitedDate) => NonNullable<CommitedDate>;
+    clearDateInput: () => void;
+    initViewYear: number | undefined;
+    initViewMonthYear: string | undefined;
+    initViewDayMonthYear: string | undefined;
+};
+export {};

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

@@ -0,0 +1,21 @@
+type CommitedDate = string | undefined;
+export declare function useDateTimeManager(): {
+    createCommitDateTime: (prev: CommitedDate) => NonNullable<CommitedDate>;
+    createCommitDateTimeWithoutClearing: (prev: CommitedDate) => NonNullable<CommitedDate>;
+    setInput: <K extends "year" | "monthYear" | "dayMonthYear" | "hours" | "minutes">(key: K, instance: Partial<Partial<{
+        year: number;
+        monthYear: string;
+        dayMonthYear: string;
+        hours: number;
+        minutes: number;
+    }>>[K]) => void;
+    clearDateInput: () => void;
+    initViewYear: number | undefined;
+    initViewMonthYear: string | undefined;
+    initViewDayMonthYear: string | undefined;
+    initViewHours: number | undefined;
+    initViewMinutes: number | undefined;
+    getPreviewDate: (instance: CommitedDate) => string | undefined;
+    getPreviewTime: (instance: CommitedDate) => string | undefined;
+};
+export {};

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

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

package/dist/types/src/ui/datePickersV2/hooks/feeds/days/useDaysFeed.d.ts

@@ -0,0 +1,19 @@
+import { InfinityFeedState } from '../../../../../hooks';
+import { useDaysGrid } from './useDaysGrid';
+export type Day = string;
+export type DaysFeedState = InfinityFeedState<Day>;
+type PropsType = Pick<ReturnType<typeof useDaysGrid>, 'getCellRef'>;
+export declare function useDaysFeed(props: PropsType): {
+    getElementByItem: (item: string) => HTMLElement | null;
+    getElementsBefore: (instance: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    getElementsAfter: (instance: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    removeElementsAfter: (firstElement: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    removeElementsBefore: (lastElement: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    getElementsAround: (instance: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    feedState: [state: DaysFeedState, set: {
+        asyncEffect: (value: import('react').SetStateAction<DaysFeedState>) => Promise<DaysFeedState>;
+        asyncLayout: (value: import('react').SetStateAction<DaysFeedState>) => Promise<DaysFeedState>;
+        asyncDom: (value: import('react').SetStateAction<DaysFeedState>) => Promise<DaysFeedState>;
+    }, getState: () => DaysFeedState];
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/days/useDaysFeedManager.d.ts

@@ -0,0 +1,12 @@
+import { Day, useDaysFeed } from './useDaysFeed';
+import { useDaysGrid } from './useDaysGrid';
+import { useIntersectionViewMonth } from './useIntersectionViewMonth';
+type PropsType = Pick<ReturnType<typeof useDaysFeed>, 'removeElementsAfter' | 'removeElementsBefore' | 'getElementsBefore' | 'getElementsAfter' | 'getElementsAround' | 'getElementByItem' | 'feedState'> & Pick<ReturnType<typeof useDaysGrid>, 'feedRef' | 'clearEmptyCellsRefs'> & Pick<ReturnType<typeof useIntersectionViewMonth>, 'updateCellsObservers' | 'mostIntersectingMonth'> & {
+    initViewDay?: Day;
+};
+export declare function useDaysFeedManager(props: PropsType): {
+    onPrevMonth: () => void;
+    onNextMonth: () => void;
+    scrollToDayMonth: (instance: Day, behavior?: ScrollBehavior) => Promise<void>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/days/useDaysFeedProvider.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { Header } from '../../../ui/feeds/days/components';
+import { useDaysFeedManager } from './useDaysFeedManager';
+import { useDaysGridManager } from './useDaysGridManager';
+import { useDaysFeedRef } from './useDaysFeedRef';
+import { useDaysInfoRequests } from './useDaysInfoRequests';
+type PropsType = Pick<Parameters<typeof useDaysGridManager>[number], 'day' | 'onClickDay'> & Pick<Parameters<typeof useDaysFeedManager>[number], 'initViewDay'> & Pick<Parameters<typeof useDaysFeedRef>[number], 'instanceRef'> & Pick<Parameters<typeof useDaysInfoRequests>[number], 'requestedDaysData' | 'requestDaysData'> & Pick<React.ComponentProps<typeof Header>, 'onClickMonth' | 'onClickYear'>;
+export declare function useDaysFeedProvider(props: PropsType): {
+    list: import("react/jsx-runtime").JSX.Element[];
+    currentViewYear: string | undefined;
+    onPrevMonth: () => void;
+    onNextMonth: () => void;
+    feedRef: React.RefObject<HTMLUListElement>;
+    feedWrapperRef: React.RefObject<HTMLDivElement>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/days/useDaysFeedRef.d.ts

@@ -0,0 +1,14 @@
+import { ComponentInstanceRef, InstanceRefAttributes } from '../../../../../types';
+import { FeedWrapper } from '../../../ui/feeds/days/components';
+import { Day } from './useDaysFeed';
+import { useDaysFeedManager } from './useDaysFeedManager';
+type FeedWrapperElement = ComponentInstanceRef<typeof FeedWrapper>;
+type RefType = {
+    scrollToDayMonth: (instance: Day) => Promise<void>;
+    element: FeedWrapperElement;
+};
+type PropsType = InstanceRefAttributes<RefType> & Pick<ReturnType<typeof useDaysFeedManager>, 'scrollToDayMonth'>;
+export declare function useDaysFeedRef(props: PropsType): {
+    feedWrapperRef: import('react').RefObject<HTMLDivElement>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/days/useDaysGrid.d.ts

@@ -0,0 +1,14 @@
+import { ComponentInstanceRef } from '../../../../../types';
+import { CalendarDay } from '../../../ui/components';
+import { GridWrapper } from '../../../ui/feeds/month/components';
+import { Day } from './useDaysFeed';
+export type MonthsCellElement = ComponentInstanceRef<typeof CalendarDay>;
+export type MonthsGridElement = ComponentInstanceRef<typeof GridWrapper>;
+export declare function useDaysGrid(): {
+    feedRef: import('react').RefObject<HTMLUListElement>;
+    getCellRef: (key: string | number) => HTMLLIElement | undefined;
+    addCellRef: (key: string | number, element: HTMLLIElement | null) => void;
+    clearEmptyCellsRefs: () => void;
+    getCellsElements: () => Map<string | number, HTMLLIElement>;
+    getDayByCellElement: (instance: Element) => Day | null;
+};

package/dist/types/src/ui/datePickersV2/hooks/feeds/days/useDaysGridDisplay.d.ts

@@ -0,0 +1,11 @@
+import { useDaysFeed } from './useDaysFeed';
+import { useDaysGrid } from './useDaysGrid';
+import { useDaysGridManager } from './useDaysGridManager';
+import { useIntersectionViewMonth } from './useIntersectionViewMonth';
+import { useDaysInfoRequests } from './useDaysInfoRequests';
+type PropsType = Pick<ReturnType<typeof useDaysFeed>, 'feedState'> & Pick<ReturnType<typeof useDaysGridManager>, 'isChosenDay' | 'onClickCell' | 'isBetweenChosenDay'> & Pick<ReturnType<typeof useDaysGrid>, 'addCellRef'> & Pick<ReturnType<typeof useIntersectionViewMonth>, 'mostIntersectingMonth'> & Pick<ReturnType<typeof useDaysInfoRequests>, 'getDayItemData'>;
+export declare function useDaysGridDisplay(props: PropsType): {
+    list: import("react/jsx-runtime").JSX.Element[];
+    currentViewYear: string | undefined;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/days/useDaysGridManager.d.ts

@@ -0,0 +1,12 @@
+import { Day } from './useDaysFeed';
+type PropsType = {
+    day?: Day | Array<Day>;
+    onClickDay: (day: Day) => void;
+};
+export declare function useDaysGridManager(props: PropsType): {
+    isChosenDay: (instance: Day) => boolean;
+    isBetweenChosenDay: (instance: Day) => boolean;
+    onClickCell: (day: Day) => void;
+    day: string | string[] | undefined;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/days/useDaysInfoRequests.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { CalendarDay } from '../../../ui/components';
+import { useDaysFeed, Day } from './useDaysFeed';
+type CalendarDayPayloadProps = Pick<React.ComponentProps<typeof CalendarDay>, 'mark' | 'weekend' | 'info'>;
+type DaysFeedDayItemData = CalendarDayPayloadProps & {
+    day: Day;
+};
+export type DaysFeedRequestDaysData = (from: Day, to: Day) => any;
+export type DaysFeedDaysData = Array<DaysFeedDayItemData>;
+type PropsType = Pick<ReturnType<typeof useDaysFeed>, 'feedState'> & {
+    requestDaysData?: DaysFeedRequestDaysData;
+    requestedDaysData?: DaysFeedDaysData;
+};
+export declare function useDaysInfoRequests(props: PropsType): {
+    getDayItemData: (instance: Day) => CalendarDayPayloadProps;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/days/useIntersectionViewMonth.d.ts

@@ -0,0 +1,7 @@
+import { useDaysGrid } from './useDaysGrid';
+type PropsType = Pick<ReturnType<typeof useDaysGrid>, 'getCellsElements' | 'getDayByCellElement' | 'feedRef'>;
+export declare function useIntersectionViewMonth(props: PropsType): {
+    updateCellsObservers: () => void;
+    mostIntersectingMonth: string | undefined;
+};
+export {};

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

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

package/dist/types/src/ui/datePickersV2/hooks/feeds/month/useMonthGrid.d.ts

@@ -0,0 +1,14 @@
+import { ComponentInstanceRef } from '../../../../../types';
+import { CalendarMonth } from '../../../ui/components';
+import { GridWrapper } from '../../../ui/feeds/month/components';
+import { Month } from './useMonthsFeed';
+export type MonthsCellElement = ComponentInstanceRef<typeof CalendarMonth>;
+export type MonthsGridElement = ComponentInstanceRef<typeof GridWrapper>;
+export declare function useMonthGrid(): {
+    feedRef: import('react').RefObject<HTMLUListElement>;
+    getCellRef: (key: string | number) => HTMLLIElement | undefined;
+    addCellRef: (key: string | number, element: HTMLLIElement | null) => void;
+    clearEmptyCellsRefs: () => void;
+    getCellsElements: () => Map<string | number, HTMLLIElement>;
+    getMonthByCellElement: (instance: Element) => Month | null;
+};

package/dist/types/src/ui/datePickersV2/hooks/feeds/month/useMonthGridDisplay.d.ts

@@ -0,0 +1,10 @@
+import { useMonthsFeed } from './useMonthsFeed';
+import { useMonthGrid } from './useMonthGrid';
+import { useMonthsGridManager } from './useMonthsGridManager';
+import { useViewMonth } from './useViewMonth';
+type PropsType = Pick<ReturnType<typeof useMonthsFeed>, 'feedState'> & Pick<ReturnType<typeof useMonthsGridManager>, 'isChosenMonth' | 'onClickCell'> & Pick<ReturnType<typeof useMonthGrid>, 'addCellRef'> & Pick<ReturnType<typeof useViewMonth>, 'mostIntersectingMonth'>;
+export declare function useMonthGridDisplay(props: PropsType): {
+    list: import("react/jsx-runtime").JSX.Element[];
+    currentViewYear: number | undefined;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/month/useMonthsFeed.d.ts

@@ -0,0 +1,23 @@
+import { DateArg } from 'date-fns';
+import { InfinityFeedState } from '../../../../../hooks';
+import { useMonthGrid } from './useMonthGrid';
+export type Month = string;
+export declare const MONTHS_VIEW_COUNT = 18;
+export declare const MONTHS_BATCH_SIZE: number;
+export declare const TARGET_MONTHS_INDEX = 7;
+type PropsType = Pick<ReturnType<typeof useMonthGrid>, 'getCellRef'>;
+export declare function useMonthsFeed(props: PropsType): {
+    getMonthData: (instance: DateArg<Date>) => string;
+    getElementByItem: (item: string) => HTMLElement | null;
+    getElementsBefore: (instance: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    getElementsAfter: (instance: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    removeElementsAfter: (firstElement: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    removeElementsBefore: (lastElement: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    getElementsAround: (instance: string, prev: InfinityFeedState<string>) => InfinityFeedState<string>;
+    feedState: [state: InfinityFeedState<string>, set: {
+        asyncEffect: (value: import('react').SetStateAction<InfinityFeedState<string>>) => Promise<InfinityFeedState<string>>;
+        asyncLayout: (value: import('react').SetStateAction<InfinityFeedState<string>>) => Promise<InfinityFeedState<string>>;
+        asyncDom: (value: import('react').SetStateAction<InfinityFeedState<string>>) => Promise<InfinityFeedState<string>>;
+    }, getState: () => InfinityFeedState<string>];
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/month/useMonthsFeedManager.d.ts

@@ -0,0 +1,12 @@
+import { useMonthsFeed, Month } from './useMonthsFeed';
+import { useMonthGrid } from './useMonthGrid';
+import { useViewMonth } from './useViewMonth';
+type PropsType = Pick<ReturnType<typeof useMonthsFeed>, 'removeElementsAfter' | 'removeElementsBefore' | 'getElementsBefore' | 'getElementsAfter' | 'getElementsAround' | 'getElementByItem' | 'getMonthData' | 'feedState'> & Pick<ReturnType<typeof useMonthGrid>, 'feedRef' | 'clearEmptyCellsRefs'> & Pick<ReturnType<typeof useViewMonth>, 'updateCellsObservers' | 'mostIntersectingMonth'> & {
+    initViewMonth?: Month;
+};
+export declare function useMonthsFeedManager(props: PropsType): {
+    onPrevYears: () => void;
+    onNextYears: () => void;
+    scrollToMonth: (month: Month, behavior?: ScrollBehavior) => Promise<void>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/month/useMonthsFeedProvider.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { Header } from '../../../ui/feeds/month/components';
+import { useMonthsFeedManager } from './useMonthsFeedManager';
+import { useMonthsGridManager } from './useMonthsGridManager';
+import { useMonthsFeedRef } from './useMonthsFeedRef';
+type PropsType = Pick<Parameters<typeof useMonthsGridManager>[number], 'onClickMonth' | 'month'> & Pick<Parameters<typeof useMonthsFeedManager>[number], 'initViewMonth'> & Pick<Parameters<typeof useMonthsFeedRef>[number], 'instanceRef'> & Pick<React.ComponentProps<typeof Header>, 'onClickYear'>;
+export declare function useMonthsFeedProvider(props: PropsType): {
+    list: import("react/jsx-runtime").JSX.Element[];
+    currentViewYear: number | undefined;
+    onPrevYears: () => void;
+    onNextYears: () => void;
+    feedRef: React.RefObject<HTMLUListElement>;
+    feedWrapperRef: React.RefObject<HTMLDivElement>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/month/useMonthsFeedRef.d.ts

@@ -0,0 +1,14 @@
+import { ComponentInstanceRef, InstanceRefAttributes } from '../../../../../types';
+import { FeedWrapper } from '../../../ui/feeds/month/components';
+import { Month } from './useMonthsFeed';
+import { useMonthsFeedManager } from './useMonthsFeedManager';
+type FeedWrapperElement = ComponentInstanceRef<typeof FeedWrapper>;
+type RefType = {
+    scrollToMonth: (instance: Month) => void;
+    element: FeedWrapperElement;
+};
+type PropsType = InstanceRefAttributes<RefType> & Pick<ReturnType<typeof useMonthsFeedManager>, 'scrollToMonth'>;
+export declare function useMonthsFeedRef(props: PropsType): {
+    feedWrapperRef: import('react').RefObject<HTMLDivElement>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/month/useMonthsGridManager.d.ts

@@ -0,0 +1,10 @@
+import { Month } from './useMonthsFeed';
+type PropsType = {
+    month?: Month;
+    onClickMonth: (month: Month) => void;
+};
+export declare function useMonthsGridManager(props: PropsType): {
+    isChosenMonth: (instance: Month) => boolean;
+    onClickCell: (month: Month) => void;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/month/useViewMonth.d.ts

@@ -0,0 +1,7 @@
+import { useMonthGrid } from './useMonthGrid';
+type PropsType = Pick<ReturnType<typeof useMonthGrid>, 'getCellsElements' | 'getMonthByCellElement' | 'feedRef'>;
+export declare function useViewMonth(props: PropsType): {
+    updateCellsObservers: () => void;
+    mostIntersectingMonth: string | undefined;
+};
+export {};

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

@@ -0,0 +1,3 @@
+export * from './useFeedTracks';
+export * from './useBaseFeed';
+export * from './usePreviewFeed';

package/dist/types/src/ui/datePickersV2/hooks/feeds/time/feed/useBaseFeed.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { InstanceRefAttributes } from '../../../../../../types';
+import { TimeCell } from '../../../../ui/feeds/time/components';
+import { ElementItem, useFeedList } from './utils';
+type FeedElement = React.ComponentRef<'div'>;
+type PropsType = Pick<Parameters<typeof useFeedList>[number], 'listSize'> & InstanceRefAttributes<FeedElement> & {
+    previewElement?: ElementItem;
+};
+export declare function useBaseFeed(props: PropsType): {
+    calcStyle: (item: ElementItem, idx: number, currentScrollTop: number) => React.CSSProperties;
+    scrollTop: number;
+    elementsList: number[];
+    getElementFloor: (item: ElementItem) => React.ComponentProps<typeof TimeCell>["floor"];
+    getItemLabel: (item: ElementItem) => string;
+    feedRef: React.RefObject<HTMLDivElement>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/time/feed/useFeedTracks.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { InstanceRefAttributes } from '../../../../../../types';
+import { BaseFeed } from '../../../../ui/feeds/time/feed/BaseFeed';
+import { PreviewFeed } from '../../../../ui/feeds/time/feed/PreviewFeed';
+import { ElementItem } from './utils';
+type PreviewFeedProps = React.ComponentProps<typeof PreviewFeed>;
+type ScrollToElement = (item: ElementItem, behavior?: ScrollBehavior) => Promise<void>;
+type RefType = {
+    scrollToElement: ScrollToElement;
+};
+type PropsType = Pick<React.ComponentProps<typeof BaseFeed>, 'listSize'> & InstanceRefAttributes<RefType> & {
+    initItemView?: ElementItem;
+    onChangeElement?: PreviewFeedProps['onChangePreviewElement'];
+};
+export declare function useFeedTracks(props: PropsType): {
+    onChangePreviewElement: (item: ElementItem) => void;
+    previewElement: number | undefined;
+    previewFeedRef: React.RefObject<HTMLDivElement>;
+    baseFeedRef: React.RefObject<HTMLDivElement>;
+    listSize: number;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/time/feed/usePreviewFeed.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { InstanceRefAttributes } from '../../../../../../types';
+import { ElementItem, useFeedList } from './utils';
+type FeedElement = React.ComponentRef<'div'>;
+type PropsType = Pick<Parameters<typeof useFeedList>[number], 'listSize'> & InstanceRefAttributes<FeedElement> & {
+    onChangePreviewElement: (item: ElementItem) => void;
+};
+export declare function usePreviewFeed(props: PropsType): {
+    feedRef: React.RefObject<HTMLDivElement>;
+    calcStyle: (item: ElementItem, idx: number, currentScrollTop: number) => React.CSSProperties;
+    elementsList: number[];
+    scrollTop: number;
+    getItemLabel: (item: ElementItem) => string;
+    updateElement: (key: string | number, element: HTMLElement | null) => void;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/time/feed/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './useMostViewedElement';
+export * from './useElementsPositionStyle';
+export * from './useFeedList';
+export * from './useFeedElementView';

package/dist/types/src/ui/datePickersV2/hooks/feeds/time/feed/utils/useElementsPositionStyle.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties } from 'react';
+import { useMostViewedElement } from './useMostViewedElement';
+import { ElementItem } from './useFeedList';
+type PropsType = Partial<Pick<ReturnType<typeof useMostViewedElement>, 'previewElement'>>;
+export declare function useElementsPositionStyle(props: PropsType): {
+    calcStyle: (item: ElementItem, idx: number, currentScrollTop: number) => CSSProperties;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/time/feed/utils/useFeedElementView.d.ts

@@ -0,0 +1,4 @@
+import { ElementItem } from './useFeedList';
+export declare function useFeedElementView(): {
+    getItemLabel: (item: ElementItem) => string;
+};

package/dist/types/src/ui/datePickersV2/hooks/feeds/time/feed/utils/useFeedList.d.ts

@@ -0,0 +1,8 @@
+export type ElementItem = number;
+type PropsType = {
+    listSize: number;
+};
+export declare function useFeedList(props: PropsType): {
+    elementsList: number[];
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/time/feed/utils/useMostViewedElement.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { useElementsRefs } from '../../../../../../../hooks';
+type PropsType = Pick<ReturnType<typeof useElementsRefs>, 'getElementsRefsEntries'> & {
+    feedRef: React.RefObject<HTMLElement>;
+};
+export declare function useMostViewedElement(props: PropsType): {
+    previewElement: number | undefined;
+};
+export {};

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

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

package/dist/types/src/ui/datePickersV2/hooks/feeds/time/useTimeFeed.d.ts

@@ -0,0 +1,28 @@
+import { ComponentInstanceRef, InstanceRefAttributes } from '../../../../../types';
+import { FeedTracks } from '../../../ui/feeds/time/feed';
+type Minutes = number;
+type Hours = number;
+type FeedTracksRef = ComponentInstanceRef<typeof FeedTracks>;
+type RefType = {
+    scrollToHour: FeedTracksRef['scrollToElement'];
+    scrollToMinute: FeedTracksRef['scrollToElement'];
+};
+type PropsType = InstanceRefAttributes<RefType> & {
+    initHoursValue?: Hours;
+    initMinutesValue?: Minutes;
+    onChangeHours: (instance: Hours) => void;
+    onChangeMinutes: (instance: Minutes) => void;
+};
+export declare function useTimeFeed(props: PropsType): {
+    hoursFeedRef: import('react').RefObject<{
+        scrollToElement: (item: import('./feed/utils').ElementItem, behavior?: ScrollBehavior) => Promise<void>;
+    }>;
+    minutesFeedRef: import('react').RefObject<{
+        scrollToElement: (item: import('./feed/utils').ElementItem, behavior?: ScrollBehavior) => Promise<void>;
+    }>;
+    initMinutesValue: number | undefined;
+    initHoursValue: number | undefined;
+    onChangeMinutes: (instance: Minutes) => void;
+    onChangeHours: (instance: Hours) => void;
+};
+export {};

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

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

package/dist/types/src/ui/datePickersV2/hooks/feeds/year/useIntersectionViewYear.d.ts

@@ -0,0 +1,7 @@
+import { useYearsGrid } from './useYearsGrid';
+type PropsType = Pick<ReturnType<typeof useYearsGrid>, 'getCellsElements' | 'getYearByCellElement' | 'feedRef'>;
+export declare function useIntersectionViewYear(props: PropsType): {
+    updateCellsObservers: () => void;
+    mostIntersectingYear: number | undefined;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/year/useYearFeedRef.d.ts

@@ -0,0 +1,14 @@
+import { ComponentInstanceRef, InstanceRefAttributes } from '../../../../../types';
+import { FeedWrapper } from '../../../ui/feeds/year/components';
+import { Year } from './useYearsFeed';
+import { useYearsFeedManager } from './useYearsFeedManager';
+type FeedWrapperElement = ComponentInstanceRef<typeof FeedWrapper>;
+type RefType = {
+    scrollToYear: (instance: Year) => void;
+    element: FeedWrapperElement;
+};
+type PropsType = InstanceRefAttributes<RefType> & Pick<ReturnType<typeof useYearsFeedManager>, 'scrollToYear'>;
+export declare function useYearFeedRef(props: PropsType): {
+    feedWrapperRef: import('react').RefObject<HTMLDivElement>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/year/useYearGridDisplay.d.ts

@@ -0,0 +1,10 @@
+import { useYearsFeed } from './useYearsFeed';
+import { useYearsGrid } from './useYearsGrid';
+import { useYearsGridManager } from './useYearsGridManager';
+import { useIntersectionViewYear } from './useIntersectionViewYear';
+type PropsType = Pick<ReturnType<typeof useYearsFeed>, 'feedState'> & Pick<ReturnType<typeof useYearsGridManager>, 'isChosenYear' | 'onClickCell'> & Pick<ReturnType<typeof useYearsGrid>, 'addCellRef'> & Pick<ReturnType<typeof useIntersectionViewYear>, 'mostIntersectingYear'>;
+export declare function useYearGridDisplay(props: PropsType): {
+    list: import("react/jsx-runtime").JSX.Element[];
+    currentViewYear: string;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/year/useYearsFeed.d.ts

@@ -0,0 +1,22 @@
+import { InfinityFeedState } from '../../../../../hooks';
+import { useYearsGrid } from './useYearsGrid';
+export type Year = number;
+export declare const YEARS_TARGET_COUNT = 9;
+export declare const YEARS_VIEW_COUNT = 15;
+export declare const YEARS_BATCH_SIZE: number;
+export declare const TARGET_YEAR_INDEX = 7;
+type PropsType = Pick<ReturnType<typeof useYearsGrid>, 'getCellRef'>;
+export declare function useYearsFeed(props: PropsType): {
+    getElementByItem: (item: number) => HTMLElement | null;
+    getElementsBefore: (instance: number, prev: InfinityFeedState<number>) => InfinityFeedState<number>;
+    getElementsAfter: (instance: number, prev: InfinityFeedState<number>) => InfinityFeedState<number>;
+    removeElementsAfter: (firstElement: number, prev: InfinityFeedState<number>) => InfinityFeedState<number>;
+    removeElementsBefore: (lastElement: number, prev: InfinityFeedState<number>) => InfinityFeedState<number>;
+    getElementsAround: (instance: number, prev: InfinityFeedState<number>) => InfinityFeedState<number>;
+    feedState: [state: InfinityFeedState<number>, set: {
+        asyncEffect: (value: import('react').SetStateAction<InfinityFeedState<number>>) => Promise<InfinityFeedState<number>>;
+        asyncLayout: (value: import('react').SetStateAction<InfinityFeedState<number>>) => Promise<InfinityFeedState<number>>;
+        asyncDom: (value: import('react').SetStateAction<InfinityFeedState<number>>) => Promise<InfinityFeedState<number>>;
+    }, getState: () => InfinityFeedState<number>];
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/year/useYearsFeedManager.d.ts

@@ -0,0 +1,12 @@
+import { useYearsFeed, Year } from './useYearsFeed';
+import { useYearsGrid } from './useYearsGrid';
+import { useIntersectionViewYear } from './useIntersectionViewYear';
+type PropsType = Pick<ReturnType<typeof useYearsFeed>, 'removeElementsAfter' | 'removeElementsBefore' | 'getElementsBefore' | 'getElementsAfter' | 'getElementsAround' | 'getElementByItem' | 'feedState'> & Pick<ReturnType<typeof useYearsGrid>, 'feedRef' | 'clearEmptyCellsRefs'> & Pick<ReturnType<typeof useIntersectionViewYear>, 'updateCellsObservers' | 'mostIntersectingYear'> & {
+    initViewYear?: Year;
+};
+export declare function useYearsFeedManager(props: PropsType): {
+    onPrevYears: () => void;
+    onNextYears: () => void;
+    scrollToYear: (year: Year, behavior?: ScrollBehavior) => Promise<void>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/year/useYearsFeedProvider.d.ts

@@ -0,0 +1,13 @@
+import { useYearsGridManager } from './useYearsGridManager';
+import { useYearsFeedManager } from './useYearsFeedManager';
+import { useYearFeedRef } from './useYearFeedRef';
+type PropsType = Pick<Parameters<typeof useYearsGridManager>[number], 'year' | 'onClickYear'> & Pick<Parameters<typeof useYearsFeedManager>[number], 'initViewYear'> & Pick<Parameters<typeof useYearFeedRef>[number], 'instanceRef'>;
+export declare function useYearsFeedProvider(props: PropsType): {
+    list: import("react/jsx-runtime").JSX.Element[];
+    currentViewYear: string;
+    onPrevYears: () => void;
+    onNextYears: () => void;
+    feedRef: import('react').RefObject<HTMLUListElement>;
+    feedWrapperRef: import('react').RefObject<HTMLDivElement>;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/feeds/year/useYearsGrid.d.ts

@@ -0,0 +1,14 @@
+import { ComponentInstanceRef } from '../../../../../types';
+import { CalendarYear } from '../../../ui/components';
+import { GridWrapper } from '../../../ui/feeds/year/components';
+import { Year } from './useYearsFeed';
+export type YearsCellElement = ComponentInstanceRef<typeof CalendarYear>;
+export type YearsGridElement = ComponentInstanceRef<typeof GridWrapper>;
+export declare function useYearsGrid(): {
+    feedRef: import('react').RefObject<HTMLUListElement>;
+    getCellRef: (key: string | number) => HTMLLIElement | undefined;
+    addCellRef: (key: string | number, element: HTMLLIElement | null) => void;
+    clearEmptyCellsRefs: () => void;
+    getCellsElements: () => Map<string | number, HTMLLIElement>;
+    getYearByCellElement: (instance: Element) => Year | null;
+};

package/dist/types/src/ui/datePickersV2/hooks/feeds/year/useYearsGridManager.d.ts

@@ -0,0 +1,10 @@
+import { Year } from './useYearsFeed';
+type PropsType = {
+    year?: Year;
+    onClickYear: (year: Year) => void;
+};
+export declare function useYearsGridManager(props: PropsType): {
+    isChosenYear: (instance: Year) => boolean;
+    onClickCell: (year: Year) => void;
+};
+export {};

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

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