@t-headless-ui/react 1.1.1 → 1.1.3

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

@@ -0,0 +1,212 @@
+import { ReactNode, HTMLAttributes } from 'react';
+import { RefInputType } from '../input/interface';
+/**
+ * @title InputTag.Root Props
+ */
+export interface InputTagRootProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    /**
+     * @zh 默认 tag 值
+     * @en To set default tag value
+     */
+    defaultValue?: (ObjectValueType | string)[];
+    /**
+     * @zh tag 值
+     * @en To set tag value
+     */
+    value?: (ObjectValueType | string)[];
+    /**
+     * @zh 输入框内的值
+     * @en To set input value
+     */
+    inputValue?: string;
+    /**
+     * @zh 是否禁用
+     * @en Whether the input is disabled
+     */
+    disabled?: boolean;
+    /**
+     * @zh 是否禁用输入框
+     * @en Whether the input is disabled
+     */
+    disableInput?: boolean;
+    /**
+     * @zh 是否只读
+     * @en Whether the input is read only
+     */
+    readOnly?: boolean;
+    /**
+     * @zh 移除某一个标签时改变时触发
+     * @en Callback when a tag is removed
+     */
+    onRemove?: (value: ObjectValueType, index: number, event: any) => void;
+    /**
+     * @zh 控件值改变时触发
+     * @en Callback when value changes
+     */
+    onChange?: (value: any[], reason: ValueChangeReason) => void;
+    /**
+     * @zh 设置传入和回调出的值均为 `{ label: '', value: ''}` 格式。
+     * @en If true, the incoming and callback values will be `{label: '', value: '')` format
+     */
+    labelInValue?: boolean;
+    /**
+     * @zh 最大标签数, 支持自定义渲染
+     * @en Maximum number of tags, support custom rendering
+     */
+    maxTagCount?: number | {
+        count: number;
+        render: (hiddenList: ObjectValueType[]) => ReactNode;
+    };
+    /**
+     * @zh 自定义 ref, 返回 div 元素
+     * @en Custom ref, return div element
+     */
+    ref?: React.Ref<InputTagHandle>;
+    /**
+     * @zh 是否聚焦
+     * @en Whether the input is focused
+     */
+    focused?: boolean;
+    /**
+     * @zh 校验函数，默认在 按下enter时候触发。
+     * @en Function to check user's input, which is triggered when `Enter` is pressed
+     * @default (inputValue, values) => inputValue && values.every((item) => item !== inputValue)
+     */
+    validate?: (inputValue: string, values: ObjectValueType[]) => boolean | Promise<boolean> | ObjectValueType | Promise<ObjectValueType>;
+    /**
+     * @zh 触发自动分词的分隔符
+     * @en Separator used to tokenize
+     */
+    tokenSeparators?: string[];
+}
+/**
+ * @title InputTag.Input Props
+ */
+export interface InputTagInputProps {
+    /**
+     * @zh 自定义类名
+     * @en Custom class name
+     */
+    className?: string;
+    /**
+     * @zh 自定义样式
+     * @en Custom style
+     */
+    style?: React.CSSProperties;
+    /**
+     * @zh 预设文案
+     * @en Placeholder of input element
+     */
+    placeholder?: string;
+    /**
+     * @zh 是否在失焦时自动存储正在输入的文本
+     * @en Whether to automatically store the text entering when blur InputTag
+     */
+    saveOnBlur?: boolean;
+    /**
+     * @zh 失去焦点时候触发
+     * @en Callback when input is blurred
+     */
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    /**
+     * @zh 聚焦时触发
+     * @en Callback when input is focused
+     */
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    /**
+     * @zh 按 enter 键触发
+     * @en Callback when `Enter` key is pressed
+     */
+    onPressEnter?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    /**
+     * @zh 输入框文本改变的回调。
+     * @en Callback when the value of input changes
+     */
+    onInputChange?: (inputValue: string, event?: React.ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * @zh 键盘事件回调
+     * @en Callback when the keyboard is pressed
+     */
+    onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    /**
+     * @zh 输入框文本粘贴的回调。
+     * @en Callback when you paste text in input box
+     */
+    onPaste?: (e: React.ClipboardEvent<HTMLInputElement>) => void;
+    /**
+     * @zh 返回 Input 元素的 blur, focus 方法, 以及 inputDom 方法获取 Input 元素
+     * @en Custom ref, return input element's blur, focus method, and inputDom method to get input element
+     */
+    ref?: React.Ref<RefInputType>;
+}
+/**
+ * @title InputTag.Tag Props
+ */
+export interface InputTagProps {
+    /**
+     * @zh 自定义标签渲染，`props` 为当前标签属性和组件状态，`index` 为当前标签的顺序，`values` 为所有标签的值.
+     * @en Custom tag rendering, `props` is the current tag attribute and component state, `index` is the order of the current tag, `values` is the value of all tags
+     */
+    renderTag?: (props: {
+        value: any;
+        label: ReactNode;
+        closable: boolean;
+        onClose: (event: React.MouseEvent) => void;
+        readOnly: boolean;
+        disabled: boolean;
+    }, index: number, values: ObjectValueType[]) => ReactNode;
+}
+/**
+ * @title InputTag.Clear Props
+ */
+export interface InputClearProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * @zh 自定义清除图标
+     * @en Custom clear icon
+     */
+    children?: ReactNode;
+}
+/**
+ * @title ObjectValueType
+ */
+export type ObjectValueType = {
+    /**
+     * @zh 标签值
+     * @en Tag value
+     */
+    value?: any;
+    /**
+     * @zh 标签显示文案
+     * @en Tag display text
+     */
+    label?: ReactNode;
+    /**
+     * @zh 是否可关闭
+     * @en Whether the tag is closable
+     */
+    disabled?: boolean;
+};
+/**
+ * @title ValueChangeReason
+ */
+export type ValueChangeReason = 'add' | 'remove' | 'clear' | 'sort';
+/**
+ * @title InputTag ref
+ */
+export type InputTagHandle = {
+    /**
+     * @zh 聚焦输入框
+     * @en Focus the input box
+     */
+    focus?: () => void;
+    /**
+     * @zh 失焦输入框
+     * @en Blur the input box
+     */
+    blur?: () => void;
+    /**
+     * @zh 输入框 dom元素
+     * @en Input box dom element
+     */
+    dom?: HTMLDivElement;
+};

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

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

package/dist/types/input-tag/store/useInputTagStore.d.ts

@@ -0,0 +1,27 @@
+import { InputTagRootProps, ObjectValueType } from '../interface';
+import { RefInputType } from '../../input/interface';
+interface useInputTagStoreProps {
+    defaultValue: InputTagRootProps['defaultValue'];
+    propsValue: InputTagRootProps['value'];
+    propsInputValue: InputTagRootProps['inputValue'];
+    readOnly: InputTagRootProps['readOnly'];
+    disabled: InputTagRootProps['disabled'];
+    onRemove: InputTagRootProps['onRemove'];
+    onChange: InputTagRootProps['onChange'];
+    labelInValue: InputTagRootProps['labelInValue'];
+    propsFocused: InputTagRootProps['focused'];
+}
+export declare function useInputTagStore(props: useInputTagStoreProps): {
+    refInput: import('react').RefObject<RefInputType>;
+    refWrapper: import('react').RefObject<HTMLDivElement>;
+    refTSLastSeparateTriggered: import('react').RefObject<number>;
+    focused: boolean;
+    setFocused: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    value: ObjectValueType[];
+    setValue: import('react').Dispatch<import('react').SetStateAction<ObjectValueType[]>>;
+    inputValue: string;
+    setInputValue: import('react').Dispatch<import('react').SetStateAction<string>>;
+    hotkeyHandler: (event: import('react').KeyboardEvent) => void;
+    handleClearClick: (e: any) => void;
+};
+export {};

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

@@ -0,0 +1,10 @@
+import { ObjectValueType } from '../interface';
+export declare function formatValue(value: (ObjectValueType | string)[]): ({
+    label: any;
+    value: any;
+    closable: boolean;
+    disabled?: boolean;
+} | {
+    label: string;
+    value: string;
+})[];

package/dist/types/input-tag/utils/handleTokenSeparators.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { InputTagRootProps, ObjectValueType } from '../interface';
+interface HandleTokenSeparatorsProps {
+    str: string;
+    refTSLastSeparateTriggered: React.RefObject<number>;
+    tokenSeparators: InputTagRootProps['tokenSeparators'];
+    validate: InputTagRootProps['validate'];
+    value: ObjectValueType[];
+    disabled: InputTagRootProps['disabled'];
+    readOnly: InputTagRootProps['readOnly'];
+    setValue: React.Dispatch<React.SetStateAction<ObjectValueType[]>>;
+    onChange: InputTagRootProps['onChange'];
+    labelInValue: InputTagRootProps['labelInValue'];
+}
+export declare function handleTokenSeparators({ str, refTSLastSeparateTriggered, tokenSeparators, validate, value, disabled, readOnly, setValue, onChange, labelInValue, }: HandleTokenSeparatorsProps): Promise<void>;
+export {};

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

@@ -0,0 +1,8 @@
+export * from './isEmptyNode';
+export * from './keepFocus';
+export * from './formatValue';
+export * from './tryAddInputValueToTag';
+export * from './valueChangeHandler';
+export * from './tagCloseHandler';
+export * from './mergedRenderTag';
+export * from './handleTokenSeparators';

package/dist/types/input-tag/utils/isEmptyNode.d.ts

@@ -0,0 +1,2 @@
+import { ReactNode } from 'react';
+export declare function isEmptyNode(node: ReactNode): boolean;

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

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

package/dist/types/input-tag/utils/mergedRenderTag.d.ts

@@ -0,0 +1,13 @@
+import { InputTagRootProps, InputTagProps, ObjectValueType } from '../interface';
+export declare function mergedRenderTag({ readOnly, item, disabled, index, renderTag, value, onRemove, setValue, onChange, labelInValue, }: {
+    item: ObjectValueType;
+    index: number;
+    onRemove: InputTagRootProps['onRemove'];
+    value: ObjectValueType[];
+    disabled: InputTagRootProps['disabled'];
+    readOnly: InputTagRootProps['readOnly'];
+    setValue: React.Dispatch<React.SetStateAction<ObjectValueType[]>>;
+    onChange: InputTagRootProps['onChange'];
+    labelInValue: InputTagRootProps['labelInValue'];
+    renderTag: InputTagProps['renderTag'];
+}): import('react').ReactNode;

package/dist/types/input-tag/utils/tagCloseHandler.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { InputTagRootProps, ObjectValueType } from '../interface';
+interface TagCloseHandlerProps {
+    item: ObjectValueType;
+    index: number;
+    event: any;
+    onRemove: InputTagRootProps['onRemove'];
+    value: ObjectValueType[];
+    disabled: InputTagRootProps['disabled'];
+    readOnly: InputTagRootProps['readOnly'];
+    setValue: React.Dispatch<React.SetStateAction<ObjectValueType[]>>;
+    onChange: InputTagRootProps['onChange'];
+    labelInValue: InputTagRootProps['labelInValue'];
+}
+export declare function tagCloseHandler({ item, index, event, onRemove, value, disabled, readOnly, setValue, onChange, labelInValue, }: TagCloseHandlerProps): void;
+export {};

package/dist/types/input-tag/utils/tryAddInputValueToTag.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { InputTagRootProps, ObjectValueType } from '../interface';
+interface TryAddInputValueToTagProps {
+    validate: InputTagRootProps['validate'];
+    inputValue: string;
+    value: ObjectValueType[];
+    setInputValue: React.Dispatch<React.SetStateAction<string>>;
+    disabled: InputTagRootProps['disabled'];
+    readOnly: InputTagRootProps['readOnly'];
+    setValue: React.Dispatch<React.SetStateAction<ObjectValueType[]>>;
+    onChange: InputTagRootProps['onChange'];
+    labelInValue: InputTagRootProps['labelInValue'];
+}
+export declare function tryAddInputValueToTag({ validate, inputValue, value, setInputValue, disabled, readOnly, setValue, onChange, labelInValue, }: TryAddInputValueToTagProps): Promise<void>;
+export {};

package/dist/types/input-tag/utils/valueChangeHandler.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { ObjectValueType, ValueChangeReason, InputTagRootProps } from '../interface';
+interface ValueChangeProps {
+    disabled: InputTagRootProps['disabled'];
+    readOnly: InputTagRootProps['readOnly'];
+    setValue: React.Dispatch<React.SetStateAction<ObjectValueType[]>>;
+    value: ObjectValueType[];
+    onChange: InputTagRootProps['onChange'];
+    labelInValue: InputTagRootProps['labelInValue'];
+    reason: ValueChangeReason;
+}
+export declare function valueChangeHandler({ disabled, readOnly, setValue, value, onChange, labelInValue, reason }: ValueChangeProps): void;
+export {};

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;