indicator-ui 1.1.109 → 1.1.110

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

@@ -1 +1,3 @@
-export * from './useTooltipModal';
+export * from './useTooltipFloatingModal';
+export * from './useDialogFloatingModal';
+export * from './useAnchoredFloatingModal';

package/dist/types/src/hooks/floatingUIUtils/useAnchoredFloatingModal.d.ts

@@ -0,0 +1,47 @@
+import { UseDismissProps, UseFloatingOptions } from '@floating-ui/react';
+type PropsType = Pick<UseFloatingOptions, 'placement' | 'strategy' | 'middleware'> & Pick<UseDismissProps, 'outsidePress' | 'escapeKey'> & {
+    initIsOpen?: boolean;
+    offset?: number;
+    shiftPadding?: number;
+    /** true: width = ширине якоря, 'min': только minWidth, false: не трогаем */
+    matchWidth?: boolean | 'min';
+};
+export declare function useAnchoredFloatingModal(props?: PropsType): {
+    floatingStyles: import('react').CSSProperties;
+    refs: {
+        reference: import('react').MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+    open: boolean;
+    setOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    context: {
+        x: number;
+        y: number;
+        update: () => void;
+        placement: import('@floating-ui/utils').Placement;
+        strategy: import('@floating-ui/utils').Strategy;
+        middlewareData: import('@floating-ui/core').MiddlewareData;
+        isPositioned: boolean;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: import('@floating-ui/react').OpenChangeReason) => void;
+        events: import('@floating-ui/react').FloatingEvents;
+        dataRef: React.MutableRefObject<import('@floating-ui/react').ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+        elements: import('@floating-ui/react').ExtendedElements<import('@floating-ui/react').ReferenceType>;
+    };
+    onOpen: () => void;
+    onClose: () => void;
+    onToggle: () => void;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getItemProps: (userProps?: Omit<React.HTMLProps<HTMLElement>, "selected" | "active"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) => Record<string, unknown>;
+};
+export {};

package/dist/types/src/hooks/floatingUIUtils/useDialogFloatingModal.d.ts

@@ -0,0 +1,37 @@
+import { UseDismissProps } from '@floating-ui/react';
+type PropsType = Pick<UseDismissProps, 'outsidePress' | 'escapeKey'> & {
+    initIsOpen?: boolean;
+    enableReferenceClick?: boolean;
+};
+export declare function useDialogFloatingModal(props?: PropsType): {
+    setDialog: ((node: HTMLElement | null) => void) & ((node: HTMLElement | null) => void);
+    setReference: ((node: import('@floating-ui/react-dom').ReferenceType | null) => void) & ((node: import('@floating-ui/react').ReferenceType | null) => void);
+    open: boolean;
+    setOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    onClose: () => void;
+    context: {
+        x: number;
+        y: number;
+        update: () => void;
+        placement: import('@floating-ui/utils').Placement;
+        strategy: import('@floating-ui/utils').Strategy;
+        middlewareData: import('@floating-ui/core').MiddlewareData;
+        isPositioned: boolean;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: import('@floating-ui/react').OpenChangeReason) => void;
+        events: import('@floating-ui/react').FloatingEvents;
+        dataRef: React.MutableRefObject<import('@floating-ui/react').ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+        elements: import('@floating-ui/react').ExtendedElements<import('@floating-ui/react').ReferenceType>;
+    };
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getItemProps: (userProps?: Omit<React.HTMLProps<HTMLElement>, "selected" | "active"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) => Record<string, unknown>;
+};
+export {};

package/dist/types/src/hooks/floatingUIUtils/{useTooltipModal.d.ts → useTooltipFloatingModal.d.ts}

@@ -9,7 +9,7 @@ type PropsType = Pick<UseFloatingOptions, 'middleware' | 'placement' | 'strategy
     arrow?: number;
     arrowheadDirection?: Side;
 };
-export declare function useTooltipModal(props: PropsType): {
+export declare function useTooltipFloatingModal(props?: PropsType): {
     refs: {
         reference: import('react').MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
         floating: React.MutableRefObject<HTMLElement | null>;
@@ -22,5 +22,23 @@ export declare function useTooltipModal(props: PropsType): {
     arrowStyle: CSSProperties;
     getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
     getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    context: {
+        x: number;
+        y: number;
+        update: () => void;
+        placement: import('@floating-ui/utils').Placement;
+        strategy: import('@floating-ui/utils').Strategy;
+        middlewareData: import('@floating-ui/core').MiddlewareData;
+        isPositioned: boolean;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: import('@floating-ui/react').OpenChangeReason) => void;
+        events: import('@floating-ui/react').FloatingEvents;
+        dataRef: React.MutableRefObject<import('@floating-ui/react').ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+        elements: import('@floating-ui/react').ExtendedElements<import('@floating-ui/react').ReferenceType>;
+    };
 };
 export {};

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

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+type PropsType = {
+    condition: any;
+    fallback?: ReactNode;
+    children?: ReactNode;
+};
+export declare function ConditionalFallback(props: PropsType): ReactNode;
+export {};

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

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

package/dist/types/src/ui/datePickersV2/hooks/pickers/dateTime/useDateTimePickerV2Provider.d.ts

@@ -15,7 +15,7 @@ type RefType = Pick<ReturnType<typeof usePickerState>, 'switchToDateMainPicker'
     dateBaseRef: React.RefObject<DateBaseRef | null>;
 };
 type PropsType = Pick<React.ComponentProps<typeof Wrapper>, 'style'> & Pick<React.ComponentProps<typeof Header>, 'title' | 'subtitle'> & Pick<React.ComponentProps<typeof Footer>, 'isShowFooter' | 'onClose'> & Pick<DateBaseProps, 'requestDaysData' | 'requestedDaysData' | 'canPickDateRange'> & InstanceRefAttributes<RefType> & {
-    wrapperRef?: React.RefObject<WrapperRef | null>;
+    wrapperRef?: React.Ref<WrapperRef | null>;
     dateTime?: DateTimeValue;
     onSubmitDate?: (dateTime: DateTimeValue) => void;
     onSubmitDateTime?: (dateTime: DateTimeValue) => void;

package/dist/types/src/ui/datePickersV2/hooks/pickers/time/useTimePickerV2Provider.d.ts

@@ -10,7 +10,7 @@ type RefType = Pick<ReturnType<typeof useTimeManager>, 'createCommitTimeWithoutC
     timeFeedRef: React.RefObject<TimeFeedRef | null>;
 };
 type PropsType = Pick<React.ComponentProps<typeof Wrapper>, 'style'> & Pick<React.ComponentProps<typeof Header>, 'title' | 'subtitle'> & Pick<React.ComponentProps<typeof Footer>, 'isShowFooter' | 'onClose'> & InstanceRefAttributes<RefType> & {
-    wrapperRef?: React.RefObject<WrapperRef | null>;
+    wrapperRef?: React.Ref<WrapperRef | null>;
     time?: TimeValue;
     onSubmitTime?: (dateTime: TimeValue) => void;
 };

package/dist/types/src/ui/datePickersV2/ui/pickers/components/Switcher.d.ts

@@ -1,6 +1,6 @@
 import { default as React } from 'react';
-import { TabButtons } from '../../../..';
-type TabButtonsProps = React.ComponentProps<typeof TabButtons>;
+import { TabV2 } from '../../../..';
+type TabButtonsProps = React.ComponentProps<typeof TabV2.Button>;
 type PropsType = {
     previewDate?: string;
     previewTime?: string;

package/dist/types/src/ui/formFields/FormPaginatedSelectField/hooks/useDropdownIcon.d.ts

@@ -1,7 +1,8 @@
-import { useModalServices } from './useModalServices';
 import { useWrapperServices } from './useWrapperServices';
 import { useInputServices } from './useInputServices';
-type PropsType = Pick<ReturnType<typeof useModalServices>, 'isOpenRef'> & Pick<ReturnType<typeof useWrapperServices>, 'blurWrapper'> & Pick<ReturnType<typeof useInputServices>, 'focusInput'>;
+type PropsType = Pick<ReturnType<typeof useWrapperServices>, 'blurWrapper'> & Pick<ReturnType<typeof useInputServices>, 'focusInput'> & {
+    isOpen: boolean;
+};
 export declare function useDropdownIcon(props: PropsType): {
     onClickChevron: () => void;
 };

package/dist/types/src/ui/formFields/FormPaginatedSelectField/hooks/useFocusEvents.d.ts

@@ -1,7 +1,6 @@
 import { default as React } from 'react';
 import { useModalServices } from './useModalServices';
-import { useWrapperServices } from './useWrapperServices';
-type PropsType = Pick<ReturnType<typeof useModalServices>, 'open' | 'close'> & Pick<ReturnType<typeof useWrapperServices>, 'wrapperRef'> & {
+type PropsType = Pick<ReturnType<typeof useModalServices>, 'onClose' | 'onOpen' | 'refs'> & {
     onBlur?: React.FocusEventHandler<HTMLElement>;
 };
 export declare function useFocusEvents(props: PropsType): {

package/dist/types/src/ui/formFields/FormPaginatedSelectField/hooks/useModalServices.d.ts

@@ -1,9 +1,14 @@
 export declare function useModalServices(): {
+    refs: {
+        reference: import('react').MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
     isOpen: boolean;
-    isOpenRef: import('react').RefObject<boolean>;
-    open: () => Promise<void>;
-    close: () => Promise<unknown>;
-    register: import('../../../../hooks/modalsFederation/federation/modalInstanceContext').RegisterModal;
-    modalRef: import('react').RefObject<HTMLUListElement | null>;
-    targetRef: import('react').RefObject<HTMLDivElement | null>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    floatingStyles: import('react').CSSProperties;
+    onClose: () => void;
+    onOpen: () => void;
 };

package/dist/types/src/ui/formFields/FormPaginatedSelectField/hooks/usePagination.d.ts

@@ -2,7 +2,7 @@ import { FetchEventFunType } from '../types';
 import { useOptionsManagement } from './useOptionsManagement';
 import { useSearching } from './useSearching';
 import { useModalServices } from './useModalServices';
-type PropsType<D, M extends boolean> = Pick<ReturnType<typeof useModalServices>, 'modalRef'> & Pick<ReturnType<typeof useOptionsManagement<D, M>>, 'addOptions' | 'setOptions' | 'curOptions'> & Pick<ReturnType<typeof useSearching<D, M>>, 'searchString'> & {
+type PropsType<D, M extends boolean> = Pick<ReturnType<typeof useModalServices>, 'refs'> & Pick<ReturnType<typeof useOptionsManagement<D, M>>, 'addOptions' | 'setOptions' | 'curOptions'> & Pick<ReturnType<typeof useSearching<D, M>>, 'searchString'> & {
     paginate?: FetchEventFunType<D>;
 };
 export declare function usePagination<D, M extends boolean>(props: PropsType<D, M>): {

package/dist/types/src/ui/formFields/FormPaginatedSelectField/hooks/useSearching.d.ts

@@ -1,8 +1,8 @@
 import { FetchEventFunType } from '../types';
 import { useOptionsManagement } from './useOptionsManagement';
-import { useModalServices } from './useModalServices';
-type PropsType<D, M extends boolean> = Pick<ReturnType<typeof useModalServices>, 'isOpenRef'> & Pick<ReturnType<typeof useOptionsManagement<D, M>>, 'setOptions' | 'curOptions'> & {
+type PropsType<D, M extends boolean> = Pick<ReturnType<typeof useOptionsManagement<D, M>>, 'setOptions' | 'curOptions'> & {
     search?: FetchEventFunType<D>;
+    isOpen: boolean;
 };
 export declare function useSearching<D, M extends boolean>(props: PropsType<D, M>): {
     onChangeSearchString: import('react').Dispatch<import('react').SetStateAction<string | null | undefined>>;

package/dist/types/src/ui/formFields/FormPaginatedSelectField/hooks/useSelectField.d.ts

@@ -20,14 +20,7 @@ export declare function useSelectField<D, M extends boolean = false>(props: Prop
     onClick: (item: OptionsExtendItemType<D>) => void;
     options: import('../types').OptionsExtendType<D>;
     onChangeSearchString: React.Dispatch<React.SetStateAction<string | null | undefined>>;
-    onFocus: React.FocusEventHandler<HTMLElement>;
-    onBlur: React.FocusEventHandler<HTMLElement>;
-    modalRef: React.RefObject<HTMLUListElement | null>;
     inputRef: React.RefObject<HTMLInputElement | null>;
-    wrapperRef: React.RefObject<HTMLDivElement | null>;
-    targetRef: React.RefObject<HTMLDivElement | null>;
-    isOpen: boolean;
-    register: import('../../../../hooks/modalsFederation/federation/modalInstanceContext').RegisterModal;
     isLoading: boolean;
     formFieldProps: {
         button?: React.ReactNode;
@@ -40,5 +33,17 @@ export declare function useSelectField<D, M extends boolean = false>(props: Prop
     onClickChevron: () => void;
     getItemLabel: (item: OptionsExtendItemType<D>) => React.ReactNode;
     error: import('../../../../hooks').FormErrorType | undefined;
+    isOpen: boolean;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    refs: {
+        reference: React.MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+    floatingStyles: React.CSSProperties;
+    onFocus: React.FocusEventHandler<HTMLElement>;
+    onBlur: React.FocusEventHandler<HTMLElement>;
 };
 export {};

package/dist/types/src/ui/formFields/FormPaginatedSelectField/hooks/useWrapperServices.d.ts

@@ -1,5 +1,6 @@
-import { default as React } from 'react';
-export declare function useWrapperServices(): {
-    wrapperRef: React.RefObject<HTMLDivElement | null>;
+import { useModalServices } from './useModalServices';
+type PropsType = Pick<ReturnType<typeof useModalServices>, 'refs'>;
+export declare function useWrapperServices(props: PropsType): {
     blurWrapper: () => void;
 };
+export {};

package/dist/types/src/ui/formFields/dates/FormDateField/hooks/useDatePickerController.d.ts

@@ -1,12 +1,10 @@
 import { default as React } from 'react';
 import { useModal } from '../../../../../hooks';
 import { DateInputValue } from './useDateDraft';
-import { useInputFieldController } from './useInputFieldController';
 import { useDateFormats } from './useDateFormats';
 export type PositionSetting = NonNullable<Parameters<typeof useModal>[1]>['position'];
-type PropsType = Pick<ReturnType<typeof useDateFormats>, 'extractDateInputToPickerInputs'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & {
+type PropsType = Pick<ReturnType<typeof useDateFormats>, 'extractDateInputToPickerInputs'> & {
     disablePicker?: boolean;
-    pickerPosition?: PositionSetting;
 };
 export declare function useDatePickerController(props: PropsType): {
     datePickerRef: React.RefObject<(Pick<{
@@ -41,12 +39,19 @@ export declare function useDatePickerController(props: PropsType): {
             } | null>;
         } | null>;
     }) | null>;
-    datePickerWrapperRef: React.RefObject<null>;
     moveToInputtedDateInPicker: (instance: DateInputValue) => Promise<(void | undefined)[]> | undefined;
     clearDateInputInPicker: () => void;
     switchingPicker: () => void;
     closePicker: () => void;
-    initPickerStylee: React.CSSProperties;
-    register: import('../../../../../hooks/modalsFederation/federation/modalInstanceContext').RegisterModal;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    pickerStyle: React.CSSProperties;
+    refs: {
+        reference: React.MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+    isOpenPicker: boolean;
 };
 export {};

package/dist/types/src/ui/formFields/dates/FormDateField/hooks/useFormDateFieldProvider.d.ts

@@ -2,7 +2,6 @@ import { default as React } from 'react';
 import { FieldPropsType } from '../../../../../hooks';
 import { DatePickerV2 } from '../../../..';
 import { DoubleInputItemProps } from './useInputFieldProps';
-import { PositionSetting } from './useDatePickerController';
 type DatePickerV2Props = React.ComponentProps<typeof DatePickerV2>;
 type ValueBaseType = string;
 type FieldProps = FieldPropsType<ValueBaseType>;
@@ -28,7 +27,6 @@ type PropsType = FieldProps & Pick<DatePickerV2Props, 'requestDaysData' | 'reque
     onDismissClick?: DoubleInputItemProps['onDismissClick'] | false;
     pickerSubtitle?: DatePickerV2Props['subtitle'];
     disablePicker?: boolean;
-    pickerPosition?: PositionSetting;
 };
 export declare function useFormDateFieldProvider(props: PropsType): {
     dateInputValue: import('./useDateDraft').DateInputValue;
@@ -113,8 +111,6 @@ export declare function useFormDateFieldProvider(props: PropsType): {
             } | null>;
         } | null>;
     }) | null>;
-    datePickerWrapperRef: React.RefObject<null>;
-    doubleInputRef: React.RefObject<HTMLDivElement | null>;
     dateInputRef: React.RefObject<HTMLInputElement | null>;
     inputDateFormat: string;
     date: string | undefined;
@@ -172,8 +168,16 @@ export declare function useFormDateFieldProvider(props: PropsType): {
     clearDate: () => void;
     isErrorInputFields: boolean | undefined;
     isDisabledInputFields: boolean | undefined;
-    initPickerStylee: React.CSSProperties;
-    register: import('../../../../../hooks/modalsFederation/federation/modalInstanceContext').RegisterModal;
+    pickerStyle: React.CSSProperties;
+    refs: {
+        reference: React.MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    isOpenPicker: boolean;
     canPickDateRange: [import('date-fns').DateArg<Date> | null, import('date-fns').DateArg<Date> | null] | undefined;
 };
 export {};

package/dist/types/src/ui/formFields/dates/FormDateField/hooks/useInputFieldController.d.ts

@@ -1,5 +1,4 @@
 export declare function useInputFieldController(): {
-    doubleInputRef: import('react').RefObject<HTMLDivElement | null>;
     dateInputRef: import('react').RefObject<HTMLInputElement | null>;
     focusOnDateField: () => void;
 };

package/dist/types/src/ui/formFields/dates/FormDateRangeField/hooks/useDateTimePickerController.d.ts

@@ -1,12 +1,10 @@
 import { default as React } from 'react';
 import { useModal } from '../../../../../hooks';
 import { DateRangeInputValue } from './useDateRangeDraft';
-import { useInputFieldController } from './useInputFieldController';
 import { useDateUtils } from './useDateUtils';
 export type PositionSetting = NonNullable<Parameters<typeof useModal>[1]>['position'];
-type PropsType = Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & Pick<ReturnType<typeof useDateUtils>, 'extractDateInputToPickerData'> & {
+type PropsType = Pick<ReturnType<typeof useDateUtils>, 'extractDateInputToPickerData'> & {
     disablePicker?: boolean;
-    pickerPosition?: PositionSetting;
 };
 export declare function useDateTimePickerController(props: PropsType): {
     dateTimePickerRef: React.RefObject<(Pick<{
@@ -36,14 +34,20 @@ export declare function useDateTimePickerController(props: PropsType): {
             } | null>;
         } | null>;
     }) | null>;
-    dateTimePickerWrapperRef: React.RefObject<null>;
     moveToInputtedDateInPicker: (instance: NonNullable<DateRangeInputValue>) => Promise<(void | undefined)[]> | undefined;
     clearDateRangeInputInPicker: () => void;
     closePicker: () => void;
     openPicker: () => void;
     switchingPicker: () => void;
-    isOpenRef: React.RefObject<boolean>;
-    pickerInitStyle: React.CSSProperties;
-    register: import('../../../../../hooks/modalsFederation/federation/modalInstanceContext').RegisterModal;
+    pickerStyle: React.CSSProperties;
+    isOpenPicker: boolean;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    refs: {
+        reference: React.MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
 };
 export {};

package/dist/types/src/ui/formFields/dates/FormDateRangeField/hooks/useFormDateRangeFieldProvider.d.ts

@@ -2,7 +2,6 @@ import { default as React } from 'react';
 import { FieldPropsType } from '../../../../../hooks';
 import { DateRangePickerV2 } from '../../../..';
 import { DoubleInputItemProps } from './useInputFieldProps';
-import { PositionSetting } from './useDateTimePickerController';
 type DateRangePickerV2Props = React.ComponentProps<typeof DateRangePickerV2>;
 export type ValueItemType = string;
 export type ValueBaseType = Array<ValueItemType>;
@@ -32,7 +31,6 @@ type PropsType = FieldProps & Pick<DateRangePickerV2Props, 'requestedDaysData' |
     onDismissClick?: DoubleInputItemProps['onDismissClick'] | false;
     pickerSubtitle?: DateRangePickerV2Props['subtitle'];
     disablePicker?: boolean;
-    pickerPosition?: PositionSetting;
 };
 export declare function useFormDateRangeFieldProvider(props: PropsType): {
     fromDateValue: import('./useDateRangeDraft').DateRangeInputValue;
@@ -260,8 +258,6 @@ export declare function useFormDateRangeFieldProvider(props: PropsType): {
             } | null>;
         } | null>;
     }) | null>;
-    dateTimePickerWrapperRef: React.RefObject<null>;
-    doubleInputRef: React.RefObject<HTMLDivElement | null>;
     fromDateInputRef: React.RefObject<HTMLInputElement | null>;
     toDateInputRef: React.RefObject<HTMLInputElement | null>;
     inputDateFormat: string;
@@ -273,8 +269,16 @@ export declare function useFormDateRangeFieldProvider(props: PropsType): {
     clearDateRange: () => void;
     isErrorInputFields: boolean | undefined;
     isDisabledInputFields: boolean | undefined;
-    pickerInitStyle: React.CSSProperties;
-    register: import('../../../../../hooks/modalsFederation/federation/modalInstanceContext').RegisterModal;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    refs: {
+        reference: React.MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    pickerStyle: React.CSSProperties;
+    isOpenPicker: boolean;
     canPickDateRange: [import('date-fns').DateArg<Date> | null, import('date-fns').DateArg<Date> | null] | undefined;
 };
 export {};

package/dist/types/src/ui/formFields/dates/FormDateRangeField/hooks/useInputFieldController.d.ts

@@ -1,5 +1,4 @@
 export declare function useInputFieldController(): {
-    doubleInputRef: import('react').RefObject<HTMLDivElement | null>;
     toDateInputRef: import('react').RefObject<HTMLInputElement | null>;
     fromDateInputRef: import('react').RefObject<HTMLInputElement | null>;
     focusOnFromDateField: () => void;

package/dist/types/src/ui/formFields/dates/FormDateRangeField/hooks/useInputFieldProps.d.ts

@@ -6,7 +6,7 @@ import { useFormDateRangeFieldProvider } from './useFormDateRangeFieldProvider';
 import { useInputFieldController } from './useInputFieldController';
 import { useDateUtils } from './useDateUtils';
 export type DoubleInputItemProps = React.ComponentProps<typeof DoubleInputItem>;
-type PropsType = Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker' | 'clearDateRangeInputInPicker' | 'openPicker' | 'switchingPicker' | 'isOpenRef' | 'closePicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnFromDateField' | 'focusOnToDateField' | 'checkFocusedFromDateInput' | 'checkFocusedToDateInput'> & Pick<ReturnType<typeof useDateRangeDraft>, 'setToDateValue' | 'setFromDateValue' | 'clearDateRangeValue' | 'isFullDateInput' | 'isFullCurrentDateInput' | 'getFromDateValue' | 'getToDateValue'> & Pick<ReturnType<typeof useDateUtils>, 'isAfterInputDate' | 'isValidDateInput'>;
+type PropsType = Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker' | 'clearDateRangeInputInPicker' | 'openPicker' | 'switchingPicker' | 'isOpenPicker' | 'closePicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnFromDateField' | 'focusOnToDateField' | 'checkFocusedFromDateInput' | 'checkFocusedToDateInput'> & Pick<ReturnType<typeof useDateRangeDraft>, 'setToDateValue' | 'setFromDateValue' | 'clearDateRangeValue' | 'isFullDateInput' | 'isFullCurrentDateInput' | 'getFromDateValue' | 'getToDateValue'> & Pick<ReturnType<typeof useDateUtils>, 'isAfterInputDate' | 'isValidDateInput'>;
 export declare function useInputFieldProps(props: PropsType): {
     onCompleteDateFrom: NonNullable<((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;

package/dist/types/src/ui/formFields/dates/FormDateTimeField/hooks/useDateTimePickerController.d.ts

@@ -1,16 +1,12 @@
-import { default as React } from 'react';
 import { useModal } from '../../../../../hooks';
 import { DateInputValue, TimeInputValue } from './useDateTimeDraft';
-import { useInputFieldController } from './useInputFieldController';
-import { useDateTimeFormats } from './useDateTimeFormats';
 import { useDateUtils } from './useDateUtils';
 export type PositionSetting = NonNullable<Parameters<typeof useModal>[1]>['position'];
-type PropsType = Pick<ReturnType<typeof useDateTimeFormats>, 'parseTimeInput' | 'parseDateInput'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & Pick<ReturnType<typeof useDateUtils>, 'extractDateInputValue' | 'extractTimeInputValue'> & {
+type PropsType = Pick<ReturnType<typeof useDateUtils>, 'extractDateInputValue' | 'extractTimeInputValue'> & {
     disablePicker?: boolean;
-    pickerPosition?: PositionSetting;
 };
 export declare function useDateTimePickerController(props: PropsType): {
-    dateTimePickerRef: React.RefObject<(Pick<{
+    dateTimePickerRef: import('react').RefObject<(Pick<{
         pickerState: "time" | "date-main";
         switchToDateMainPicker: () => void;
         switchToTimePicker: () => void;
@@ -39,21 +35,20 @@ export declare function useDateTimePickerController(props: PropsType): {
             scrollToMinute: (item: import('../../../../datePickersV2/hooks/feeds/time/feed/utils').ElementItem, behavior?: ScrollBehavior) => Promise<void>;
         } | null>;
         dateBaseRef: React.RefObject<{
-            daysFeedRef: React.RefObject<{
+            daysFeedRef: import('react').RefObject<{
                 scrollToDayMonth: (instance: import('../../../../datePickersV2/hooks/feeds/days/useDaysFeed').Day) => Promise<void>;
                 element: HTMLDivElement;
             } | null>;
-            monthsFeedRef: React.RefObject<{
+            monthsFeedRef: import('react').RefObject<{
                 scrollToMonth: (instance: import('../../../../datePickersV2/hooks/feeds/month/useMonthsFeed').Month) => void;
                 element: HTMLDivElement;
             } | null>;
-            yearsFeedRef: React.RefObject<{
+            yearsFeedRef: import('react').RefObject<{
                 scrollToYear: (instance: import('../../../../datePickersV2/hooks/feeds/year/useYearsFeed').Year) => void;
                 element: HTMLDivElement;
             } | null>;
         } | null>;
     }) | null>;
-    dateTimePickerWrapperRef: React.RefObject<HTMLDivElement | null>;
     moveToInputtedDateInPicker: (instance: DateInputValue) => Promise<(void | undefined)[]> | undefined;
     moveToInputtedTimeInPicker: (instance: TimeInputValue) => Promise<(void | undefined)[]> | undefined;
     showTimePicker: () => void;
@@ -62,8 +57,15 @@ export declare function useDateTimePickerController(props: PropsType): {
     closePicker: () => void;
     switchingPicker: () => void;
     openPicker: () => void;
-    isOpenRef: React.RefObject<boolean>;
-    pickerInitStyle: React.CSSProperties;
-    register: import('../../../../../hooks/modalsFederation/federation/modalInstanceContext').RegisterModal;
+    isOpenPicker: boolean;
+    pickerStyle: import('react').CSSProperties;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    refs: {
+        reference: import('react').MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
 };
 export {};

package/dist/types/src/ui/formFields/dates/FormDateTimeField/hooks/useFormDateTimeFieldProvider.d.ts

@@ -2,7 +2,6 @@ import { default as React } from 'react';
 import { FieldPropsType } from '../../../../../hooks';
 import { DateTimePickerV2 } from '../../../..';
 import { DoubleInputItemProps } from './useInputFieldProps';
-import { PositionSetting } from './useDateTimePickerController';
 type DateTimePickerV2Props = React.ComponentProps<typeof DateTimePickerV2>;
 type ValueBaseType = string;
 type FieldProps = FieldPropsType<ValueBaseType>;
@@ -38,7 +37,6 @@ type PropsType = FieldProps & Pick<DateTimePickerV2Props, 'requestDaysData' | 'r
     onDismissClick?: DoubleInputItemProps['onDismissClick'] | false;
     pickerSubtitle?: DateTimePickerV2Props['subtitle'];
     disablePicker?: boolean;
-    pickerPosition?: PositionSetting;
 };
 export declare function useFormDateTimeFieldProvider(props: PropsType): {
     dateInputValue: import('./useDateTimeDraft').DateInputValue;
@@ -282,8 +280,6 @@ export declare function useFormDateTimeFieldProvider(props: PropsType): {
             } | null>;
         } | null>;
     }) | null>;
-    dateTimePickerWrapperRef: React.RefObject<HTMLDivElement | null>;
-    doubleInputRef: React.RefObject<HTMLDivElement | null>;
     dateInputRef: React.RefObject<HTMLInputElement | null>;
     timeInputRef: React.RefObject<HTMLInputElement | null>;
     inputDateFormat: string;
@@ -296,8 +292,16 @@ export declare function useFormDateTimeFieldProvider(props: PropsType): {
     clearDateTime: () => void;
     isErrorInputFields: boolean | undefined;
     isDisabledInputFields: boolean | undefined;
-    pickerInitStyle: React.CSSProperties;
-    register: import('../../../../../hooks/modalsFederation/federation/modalInstanceContext').RegisterModal;
     canPickDateRange: [import('date-fns').DateArg<Date> | null, import('date-fns').DateArg<Date> | null] | undefined;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    refs: {
+        reference: React.MutableRefObject<import('@floating-ui/react-dom').ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import('@floating-ui/react-dom').ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import('@floating-ui/react').ExtendedRefs<import('@floating-ui/react').ReferenceType>;
+    pickerStyle: React.CSSProperties;
+    isOpenPicker: boolean;
 };
 export {};

package/dist/types/src/ui/formFields/dates/FormDateTimeField/hooks/useInputFieldController.d.ts

@@ -1,5 +1,4 @@
 export declare function useInputFieldController(): {
-    doubleInputRef: import('react').RefObject<HTMLDivElement | null>;
     dateInputRef: import('react').RefObject<HTMLInputElement | null>;
     timeInputRef: import('react').RefObject<HTMLInputElement | null>;
     focusOnDateField: () => void;

package/dist/types/src/ui/formFields/dates/FormDateTimeField/hooks/useInputFieldProps.d.ts

@@ -6,7 +6,7 @@ import { useFormDateTimeFieldProvider } from './useFormDateTimeFieldProvider';
 import { useInputFieldController } from './useInputFieldController';
 import { useDateUtils } from './useDateUtils';
 export type DoubleInputItemProps = React.ComponentProps<typeof DoubleInputItem>;
-type PropsType = Pick<Parameters<typeof useFormDateTimeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker' | 'moveToInputtedTimeInPicker' | 'clearDateTimeInputInPicker' | 'openPicker' | 'closePicker' | 'switchingPicker' | 'isOpenRef' | 'showTimePicker' | 'showDatePicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnTimeField' | 'focusOnDateField' | 'checkFocusedDateInput' | 'checkFocusedTimeInput'> & Pick<ReturnType<typeof useDateTimeDraft>, 'setTimeInputValue' | 'setDateInputValue' | 'clearDateTimeValue' | 'isFullDateInput'> & Pick<ReturnType<typeof useDateUtils>, 'isValidTimeInput' | 'isValidDateInput'>;
+type PropsType = Pick<Parameters<typeof useFormDateTimeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker' | 'moveToInputtedTimeInPicker' | 'clearDateTimeInputInPicker' | 'openPicker' | 'closePicker' | 'switchingPicker' | 'isOpenPicker' | 'showTimePicker' | 'showDatePicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnTimeField' | 'focusOnDateField' | 'checkFocusedDateInput' | 'checkFocusedTimeInput'> & Pick<ReturnType<typeof useDateTimeDraft>, 'setTimeInputValue' | 'setDateInputValue' | 'clearDateTimeValue' | 'isFullDateInput'> & Pick<ReturnType<typeof useDateUtils>, 'isValidTimeInput' | 'isValidDateInput'>;
 export declare function useInputFieldProps(props: PropsType): {
     onCompleteDate: NonNullable<((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;