@t-headless-ui/react 1.1.1 → 1.1.2

package/dist/types/input/interface.d.ts

@@ -0,0 +1,104 @@
+import { InputHTMLAttributes, ReactNode, ClipboardEvent } from 'react';
+/**
+ * @title Input
+ * @zh **Input 接受所有原生的属性值**
+ * @en **Input Accept all native attribute values**
+ */
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'prefix' | 'size' | 'height' | 'maxLength' | 'onFocus' | 'onBlur'> {
+    /**
+     * @zh 允许清空输入框
+     * @en Whether allow clear value
+     */
+    allowClear?: boolean;
+    /**
+     * @zh 是否禁用
+     * @en Whether the input is disabled
+     */
+    disabled?: boolean;
+    /**
+     * @zh 输入框状态
+     * @en Input box status
+     */
+    status?: 'error' | 'warning';
+    /**
+     * @zh 是否只读
+     * @en Whether the input is readOnly
+     */
+    readOnly?: boolean;
+    /**
+     * @zh 默认值
+     * @en The initial input content
+     */
+    defaultValue?: string;
+    /**
+     * @zh 输入框提示文字
+     * @en Input box prompt text
+     */
+    placeholder?: string;
+    /**
+    /**
+     * @zh 输入时的回调
+     * @en Callback when user input
+     */
+    onChange?: (value: string, e: any) => void;
+    /**
+     * @zh 点击清除按钮的回调
+     * @en Callback when click clear button
+     */
+    onClear?: (e: any) => void;
+    onFocus?: (value: any, e: any) => void;
+    onBlur?: (value: any, e: any) => void;
+    /**
+     * 粘贴事件
+     */
+    onPaste?: (e: ClipboardEvent<HTMLDivElement>) => void;
+    /**
+     * @zh 按下回车键的回调
+     * @en Callback when press enter key
+     */
+    onPressEnter?: (value: any, e: any) => void;
+    /**
+     * @zh 指定 normalize 执行的时机
+     * @en Specify the timing of normalize execution
+     * @defaultValue ['onBlur']
+     */
+    normalizeTrigger?: ('onBlur' | 'onPressEnter')[];
+    /**
+     * @zh 在指定时机对用户输入的值进行格式化处理。前后值不一致时，会触发 onChange
+     * @en Format the value entered by the user at the specified time, and when the previous and subsequent values are inconsistent, onChange will be triggered
+     */
+    normalize?: (value: string) => string;
+    /**
+     * @zh 输入框的值，受控模式
+     * @en The input content value
+     */
+    value?: string;
+    /**
+     * @zh 自定义输入框高度
+     * @en Custom input height
+     */
+    /**
+     * @zh 输入框最大输入的长度；设置 `errorOnly`为 `true` 后，超过 `maxLength` 会展示 `error` 状态，并不限制用户输入。
+     * @en The max content length；After setting `errorOnly` to `true`, if `maxLength` is exceeded, the `error` status will be displayed, and user input will not be restricted.
+     */
+    maxLength?: {
+        length?: number;
+        errorOnly?: boolean;
+    };
+    /**
+     * @zh `allowClear` 时配置清除按钮的图标。
+     * @en Configure the icon of the clear button when `allowClear`.
+     */
+    clearIcon?: ReactNode;
+    /**
+     * @zh 是否展示输入框的字符长度限制
+     * @en Whether to show the character length limit of the input box
+     */
+    showWordLimit?: boolean;
+    autoFitWidth?: boolean;
+    /**
+     * @zh 自定义设置输入框的值
+     * @en Custom set the input value
+     */
+    setValue?: (value: string) => void;
+}

package/dist/types/input/store/index.d.ts

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

package/dist/types/input/store/useInputElementStore.d.ts

@@ -0,0 +1,25 @@
+import { CSSProperties } from 'react';
+import { InputProps } from '../interface';
+export declare function useInputElementStore(props: InputProps & {
+    rest: Record<string, any>;
+}): {
+    inputProps: {
+        readOnly: boolean;
+        maxLength: number;
+        disabled: boolean;
+        placeholder: string;
+        value: string;
+        onKeyDown: import('react').KeyboardEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+        onChange: import('react').ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+        onCompositionStart: import('react').CompositionEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+        onCompositionEnd: import('react').CompositionEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+        onBlur: (e: any) => void;
+    };
+    refInput: import('react').RefObject<HTMLInputElement>;
+    refInputMirror: import('react').RefObject<HTMLSpanElement>;
+    refPrevInputWidth: import('react').RefObject<number>;
+    handleClear: (e: any) => void;
+    mirrorValue: string;
+    inputComputeStyle: CSSProperties;
+    updateInputWidth: () => void;
+};

package/dist/types/input/use-input-group.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { RefInputType } from './input';
+import { InputProps } from './interface';
+export declare function useInputGroup(props: InputProps): {
+    status: "error" | "warning";
+    setFocus: React.Dispatch<React.SetStateAction<boolean>>;
+    focus: boolean;
+    inputRef: React.RefObject<RefInputType>;
+    inputWrapperRef: React.RefObject<HTMLDivElement>;
+    hasLengthError: boolean;
+    value: string;
+    setValue: React.Dispatch<React.SetStateAction<string>>;
+    onMouseDown: (e: React.MouseEvent) => void;
+    onClick: (e: React.MouseEvent) => void;
+    onChange: (value: any, e: any) => void;
+};

package/dist/types/input/use-password-store.d.ts

@@ -0,0 +1,32 @@
+import { InputProps } from './interface';
+interface InputPasswordProps extends InputProps {
+    /**
+     * @zh 是否显示切换密码可见状态的按钮
+     * @en Whether to display the button to switch the visible state of the password
+     * @defaultValue true
+     */
+    visibilityToggle?: boolean;
+    /**
+     * @zh 初始是否显示
+     * @en To set default visibility
+     */
+    defaultVisibility?: boolean;
+    /**
+     * @zh 是否显示
+     * @zh To set visibility
+     */
+    visibility?: boolean;
+    /**
+     * @zh 点击icon时触发
+     * @en Triggered when the icon is clicked
+     */
+    onVisibilityChange?: (visibility: boolean) => void;
+}
+export declare function usePasswordStore(props: InputPasswordProps): {
+    visibility: boolean;
+    IconProps: {
+        onClick: () => void;
+        onMouseUp: (e: any) => any;
+    };
+};
+export {};

package/dist/types/input/utils/formatValue.d.ts

@@ -0,0 +1 @@
+export declare function formatValue(value: any, maxLength: undefined | number): string;

package/dist/types/input/utils/getStyleFromInput.d.ts

@@ -0,0 +1,2 @@
+import { CSSProperties } from 'react';
+export declare const getStyleFromInput: (input: HTMLElement) => CSSProperties;

package/dist/types/input/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './formatValue';
+export * from './isLengthExceeds';
+export * from './keepFocus';
+export * from './getStyleFromInput';

package/dist/types/input/utils/isLengthExceeds.d.ts

@@ -0,0 +1,5 @@
+export declare function isLengthExceeds({ mergedMaxLength, valueLength, trueMaxLength }: {
+    mergedMaxLength: any;
+    valueLength: any;
+    trueMaxLength: any;
+}): boolean;

package/dist/types/input/utils/keepFocus.d.ts

@@ -0,0 +1 @@
+export declare function keepFocus(e: any): void;

package/dist/types/mini-floating-ui/constants.d.ts

@@ -0,0 +1,14 @@
+import { BasePlacement, Placement } from './interface';
+export declare const top = "top";
+export declare const bottom = "bottom";
+export declare const right = "right";
+export declare const left = "left";
+export declare const start = "start";
+export declare const end = "end";
+export declare const clippingParents = "clippingParents";
+export declare const popper = "popper";
+export declare const reference = "reference";
+export declare const viewport = "viewport";
+export declare const basePlacements: Array<BasePlacement>;
+export declare const placements: Placement[];
+export declare const INVALID_ELEMENT_ERROR = "Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.";

package/dist/types/mini-floating-ui/createPopper.d.ts

@@ -0,0 +1,2 @@
+import { OptionsGeneric, Instance, VirtualElement } from './interface';
+export declare function createPopper(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<OptionsGeneric<any>>): Instance;

package/dist/types/mini-floating-ui/debounce.d.ts

@@ -0,0 +1 @@
+export default function debounce<T>(fn: Function): () => Promise<T>;

package/dist/types/mini-floating-ui/interface.d.ts

@@ -0,0 +1,158 @@
+import { viewport, top, bottom, right, left, popper, reference, start, end, clippingParents } from './constants';
+export type VisualViewport = EventTarget & {
+    width: number;
+    height: number;
+    offsetLeft: number;
+    offsetTop: number;
+    scale: number;
+};
+export type Func = (...args: any[]) => any;
+export type BasePlacement = typeof top | typeof bottom | typeof right | typeof left;
+export type VariationPlacement = 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'right-start' | 'right-end' | 'left-start' | 'left-end';
+export type Context = typeof popper | typeof reference;
+export type Variation = typeof start | typeof end;
+export type Boundary = Element | Array<Element> | typeof clippingParents;
+export type RootBoundary = typeof viewport | 'document';
+export type Placement = BasePlacement | VariationPlacement;
+export type Obj = {
+    [key: string]: any;
+};
+export type Rect = {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+};
+export type Offsets = {
+    y: number;
+    x: number;
+};
+export type PositioningStrategy = 'absolute' | 'fixed';
+export type StateRects = {
+    reference: Rect;
+    popper: Rect;
+};
+export declare type StateOffsets = {
+    popper: Offsets;
+    arrow?: Offsets;
+};
+type OffsetData = {
+    [key in Placement]?: Offsets;
+};
+export type State = {
+    elements: {
+        reference: Element | VirtualElement;
+        popper: HTMLElement;
+        arrow?: HTMLElement;
+    };
+    options: OptionsGeneric<any>;
+    placement: Placement;
+    strategy: PositioningStrategy;
+    orderedModifiers: Array<Modifier<any, any>>;
+    rects: StateRects;
+    scrollParents: {
+        reference: Array<Element | Window | VisualViewport>;
+        popper: Array<Element | Window | VisualViewport>;
+    };
+    styles: {
+        [key: string]: Partial<CSSStyleDeclaration>;
+    };
+    attributes: {
+        [key: string]: {
+            [key: string]: string | boolean;
+        };
+    };
+    modifiersData: {
+        arrow?: {
+            x?: number;
+            y?: number;
+            centerOffset: number;
+        };
+        hide?: {
+            isReferenceHidden: boolean;
+            hasPopperEscaped: boolean;
+            referenceClippingOffsets: SideObject;
+            popperEscapeOffsets: SideObject;
+        };
+        offset?: OffsetData;
+        preventOverflow?: Offsets;
+        popperOffsets?: Offsets;
+        [key: string]: any;
+    };
+    reset?: boolean;
+};
+declare type SetAction<S> = S | ((prev: S) => S);
+export type Instance = {
+    state: State;
+    destroy: () => void;
+    forceUpdate: () => void;
+    update: () => Promise<State>;
+    setOptions: (setOptionsAction: SetAction<Partial<OptionsGeneric<any>>>) => Promise<State>;
+};
+export declare type ModifierArguments<Options extends Obj> = {
+    state: State;
+    instance: Instance;
+    options: Options;
+    name: string;
+};
+export declare type Modifier<Name, Options extends Obj> = {
+    name: Name;
+    fn: (arg0: ModifierArguments<Options>) => State | void;
+    effect?: (arg0: ModifierArguments<Options>) => (() => void) | void;
+    options?: Options;
+    data?: Obj;
+};
+export declare type EventListeners = {
+    scroll: boolean;
+    resize: boolean;
+};
+export declare type Options = {
+    placement: Placement;
+    strategy: PositioningStrategy;
+    offsetSkidding: number;
+    offsetDistance: number;
+};
+export type OptionsGeneric<TModifier> = {
+    placement: Placement;
+    modifiers: Array<TModifier>;
+    strategy: PositioningStrategy;
+};
+export declare type UpdateCallback = (arg0: State) => void;
+export declare type ClientRectObject = {
+    x: number;
+    y: number;
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+};
+export declare type SideObject = {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+};
+export declare type Padding = number | Partial<SideObject>;
+export declare type VirtualElement = {
+    getBoundingClientRect: () => ClientRect | DOMRect;
+};
+export type Window = {
+    innerHeight: number;
+    offsetHeight: number;
+    innerWidth: number;
+    offsetWidth: number;
+    pageXOffset: number;
+    pageYOffset: number;
+    getComputedStyle: typeof getComputedStyle;
+    addEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
+    removeEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
+    Element: Element;
+    HTMLElement: HTMLElement;
+    Node: Node;
+    toString(): '[object Window]';
+    devicePixelRatio: number;
+    visualViewport?: VisualViewport;
+};
+export {};

package/dist/types/mini-floating-ui/modifiers/computeStyles.d.ts

@@ -0,0 +1,30 @@
+import { PositioningStrategy, Offsets, Modifier, Rect, BasePlacement, Variation } from '../interface';
+export declare const unsetSides: {
+    top: string;
+    right: string;
+    bottom: string;
+    left: string;
+};
+export declare function roundOffsetsByDPR({ x, y }: {
+    x: any;
+    y: any;
+}, win: Window): Offsets;
+export declare function mapToStyles({ popper, popperRect, placement, variation, offsets, position, isFixed, }: {
+    popper: HTMLElement;
+    popperRect: Rect;
+    placement: BasePlacement;
+    variation?: Variation;
+    offsets: Partial<{
+        x: number;
+        y: number;
+        centerOffset: number;
+    }>;
+    position: PositioningStrategy;
+    isFixed: boolean;
+}): {
+    transform: string;
+    position: PositioningStrategy;
+};
+export type ComputeStylesModifier = Modifier<'computeStyles', any>;
+declare const _default: ComputeStylesModifier;
+export default _default;

package/dist/types/mini-floating-ui/modifiers/flip.d.ts

@@ -0,0 +1,13 @@
+import { Modifier, Padding, Placement, Boundary, RootBoundary } from '../interface';
+export type Options = {
+    mainAxis: boolean;
+    altAxis: boolean;
+    fallbackPlacements: Array<Placement>;
+    padding: Padding;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    allowedAutoPlacements: Array<Placement>;
+};
+export type FlipModifier = Modifier<'flip', Options>;
+declare const _default: FlipModifier;
+export default _default;

package/dist/types/mini-floating-ui/modifiers/index.d.ts

@@ -0,0 +1,4 @@
+export { default as popperOffsets } from './popperOffsets';
+export { default as computeStyles } from './computeStyles';
+export { default as offset } from './offset';
+export { default as flip } from './flip';

package/dist/types/mini-floating-ui/modifiers/offset.d.ts

@@ -0,0 +1,17 @@
+import { Modifier, Rect, Offsets, Placement } from '../interface';
+export type OffsetsFunction = ({ popper, reference, placement, }: {
+    popper: Rect;
+    reference: Rect;
+    placement: Placement;
+}) => [number, number];
+type Offset = OffsetsFunction | [number, number];
+export type Options = {
+    offset: Offset;
+};
+export declare function distanceAndSkiddingToXY(placement: Placement, rects: {
+    popper: Rect;
+    reference: Rect;
+}, offset: Offset): Offsets;
+export type OffsetModifier = Modifier<'offset', Options>;
+declare const _default: OffsetModifier;
+export default _default;

package/dist/types/mini-floating-ui/modifiers/popperOffsets.d.ts

@@ -0,0 +1,4 @@
+import { Modifier } from '../interface';
+export type PopperOffsetsModifier = Modifier<'popperOffsets', object>;
+declare const _default: PopperOffsetsModifier;
+export default _default;

package/dist/types/mini-floating-ui/modifiers/preventOverflow.d.ts

@@ -0,0 +1,11 @@
+import { Boundary, RootBoundary, Modifier } from '../interface';
+export type Options = {
+    mainAxis: boolean;
+    altAxis: boolean;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    altBoundary: boolean;
+};
+export type PreventOverflowModifier = Modifier<'preventOverflow', Options>;
+declare const _default: PreventOverflowModifier;
+export default _default;

package/dist/types/mini-floating-ui/utils/areValidElements.d.ts

@@ -0,0 +1 @@
+export declare function areValidElements(...args: Array<any>): boolean;

package/dist/types/mini-floating-ui/utils/computeOffsets.d.ts

@@ -0,0 +1,7 @@
+import { ClientRectObject, Offsets, Placement, PositioningStrategy, Rect } from '../interface';
+export declare function computeOffsets({ reference, element, placement, }: {
+    reference: Rect | ClientRectObject;
+    element: Rect | ClientRectObject;
+    strategy: PositioningStrategy;
+    placement?: Placement;
+}): Offsets;

package/dist/types/mini-floating-ui/utils/contains.d.ts

@@ -0,0 +1 @@
+export declare function contains(parent: Element, child: Element): boolean;

package/dist/types/mini-floating-ui/utils/detectOverflow.d.ts

@@ -0,0 +1,10 @@
+import { Placement, Boundary, RootBoundary, Context, State, SideObject, PositioningStrategy } from '../interface';
+export type Options = {
+    placement: Placement;
+    strategy: PositioningStrategy;
+    boundary: Boundary;
+    rootBoundary: RootBoundary;
+    elementContext: Context;
+    altBoundary: boolean;
+};
+export declare function detectOverflow(state: Partial<State>, options?: Partial<Options>): SideObject;

package/dist/types/mini-floating-ui/utils/expandToHashMap.d.ts

@@ -0,0 +1,3 @@
+export declare function expandToHashMap(value: number | string | boolean, keys: Array<string>): {
+    [key: string]: number | string | boolean;
+};

package/dist/types/mini-floating-ui/utils/getAltAxis.d.ts

@@ -0,0 +1 @@
+export declare function getAltAxis(axis: 'x' | 'y'): 'x' | 'y';

package/dist/types/mini-floating-ui/utils/getBasePlacement.d.ts

@@ -0,0 +1,2 @@
+import { BasePlacement, Placement } from '../interface';
+export declare function getBasePlacement(placement: Placement): BasePlacement;

package/dist/types/mini-floating-ui/utils/getBoundingClientRect.d.ts

@@ -0,0 +1,5 @@
+import { ClientRectObject, VirtualElement } from '../interface';
+/**
+ * getBoundingClientRect width scaled
+ */
+export declare function getBoundingClientRect(element: Element | VirtualElement): ClientRectObject;

package/dist/types/mini-floating-ui/utils/getClippingRect.d.ts

@@ -0,0 +1,2 @@
+import { Boundary, RootBoundary, ClientRectObject, PositioningStrategy } from '../interface';
+export declare function getClippingRect(element: Element, boundary: Boundary, rootBoundary: RootBoundary, strategy: PositioningStrategy): ClientRectObject;

package/dist/types/mini-floating-ui/utils/getCompositeRect.d.ts

@@ -0,0 +1,2 @@
+import { Rect, VirtualElement } from '../interface';
+export declare function getCompositeRect(element: Element | VirtualElement, offsetParent: Element | Window, isFixed?: boolean): Rect;

package/dist/types/mini-floating-ui/utils/getContainingBlock.d.ts

@@ -0,0 +1 @@
+export declare function getContainingBlock(element: Element): HTMLElement | null;

package/dist/types/mini-floating-ui/utils/getDocumentElement.d.ts

@@ -0,0 +1 @@
+export declare function getDocumentElement(element: Element | Window): HTMLElement;

package/dist/types/mini-floating-ui/utils/getDocumentRect.d.ts

@@ -0,0 +1,2 @@
+import { Rect } from '../interface';
+export declare function getDocumentRect(element: HTMLElement): Rect;

package/dist/types/mini-floating-ui/utils/getFreshSideObject.d.ts

@@ -0,0 +1,2 @@
+import { SideObject } from '../interface';
+export default function getFreshSideObject(): SideObject;

package/dist/types/mini-floating-ui/utils/getHTMLElementScroll.d.ts

@@ -0,0 +1,4 @@
+export declare function getHTMLElementScroll(element: HTMLElement): {
+    scrollLeft: number;
+    scrollTop: number;
+};

package/dist/types/mini-floating-ui/utils/getLayoutRect.d.ts

@@ -0,0 +1,6 @@
+export default function getLayoutRect(element: any): {
+    x: any;
+    y: any;
+    width: number;
+    height: number;
+};

package/dist/types/mini-floating-ui/utils/getMainAxisFromPlacement.d.ts

@@ -0,0 +1,2 @@
+import { Placement } from '../interface';
+export declare function getMainAxisFromPlacement(placement: Placement): 'x' | 'y';

package/dist/types/mini-floating-ui/utils/getNodeName.d.ts

@@ -0,0 +1 @@
+export declare function getNodeName(element: any): string;

package/dist/types/mini-floating-ui/utils/getNodeScroll.d.ts

@@ -0,0 +1,4 @@
+export declare function getNodeScroll(node: any): {
+    scrollLeft: number;
+    scrollTop: number;
+};

package/dist/types/mini-floating-ui/utils/getOffsetParent.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Normally, getOffsetParent returns the offsetParent of the element
+ * The special case is when the element is fixed positioned, and the offsetParent is the containing block or window
+ * if offsetParent of the element is TableElement(Table, td, th), it will be ignore and keep looking up
+ * the offsetParent of the element, which is html or body and position is static, is window
+ */
+export declare function getOffsetParent(element: Element): any;

package/dist/types/mini-floating-ui/utils/getOppositePlacement.d.ts

@@ -0,0 +1,2 @@
+import { Placement } from '../interface';
+export declare function getOppositePlacement(placement: Placement): Placement;

package/dist/types/mini-floating-ui/utils/getOppositeVariationPlacement.d.ts

@@ -0,0 +1,2 @@
+import { Placement } from '../interface';
+export declare function getOppositeVariationPlacement(placement: Placement): Placement;

package/dist/types/mini-floating-ui/utils/getParentNode.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A Node that is the parent of the current node. The parent of an element is an Element node, a Document node, or a DocumentFragment node
+ */
+export declare function getParentNode(element: Node): Node;

package/dist/types/mini-floating-ui/utils/getScrollParent.d.ts

@@ -0,0 +1 @@
+export declare function getScrollParent(node: Node): HTMLElement;

package/dist/types/mini-floating-ui/utils/getTrueOffsetParent.d.ts

@@ -0,0 +1,4 @@
+/**
+ * ignore position = fixed element
+ */
+export declare function getTrueOffsetParent(element: Element): Element | null;

package/dist/types/mini-floating-ui/utils/getVariation.d.ts

@@ -0,0 +1,2 @@
+import { Placement, Variation } from '../interface';
+export declare function getVariation(placement: Placement): Variation;

package/dist/types/mini-floating-ui/utils/getViewportRect.d.ts

@@ -0,0 +1,7 @@
+import { PositioningStrategy } from '../interface';
+export declare function getViewportRect(element: Element, strategy: PositioningStrategy): {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+};

package/dist/types/mini-floating-ui/utils/getWindow.d.ts

@@ -0,0 +1 @@
+export default function getWindow(node: any): any;

package/dist/types/mini-floating-ui/utils/getWindowScroll.d.ts

@@ -0,0 +1,4 @@
+export declare function getWindowScroll(): {
+    scrollLeft: number;
+    scrollTop: number;
+};

package/dist/types/mini-floating-ui/utils/getWindowScrollBarX.d.ts

@@ -0,0 +1 @@
+export declare function getWindowScrollBarX(element: any): number;

package/dist/types/mini-floating-ui/utils/index.d.ts

@@ -0,0 +1,15 @@
+export * from './listScrollParents';
+export * from './getCompositeRect';
+export * from './getOffsetParent';
+export * from './mergeByName';
+export * from './areValidElements';
+export * from './computeOffsets';
+export * from './getDocumentElement';
+export * from './getBasePlacement';
+export * from './getVariation';
+export * from './getOppositePlacement';
+export * from './getOppositeVariationPlacement';
+export * from './contains';
+export * from './detectOverflow';
+export * from './within';
+export * from './getAltAxis';