@zvk/ui 0.1.0

package/dist/components/tooltip/tooltip.js

@@ -0,0 +1,100 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { Portal } from "../../internal/portal/index.js";
+import { useFloatingPosition } from "../../internal/floating/index.js";
+import { composeEventHandlers } from "../../utils/compose-event-handlers.js";
+function composeRefs(...refs) {
+    return (node) => {
+        for (const ref of refs) {
+            if (typeof ref === "function") {
+                ref(node);
+            }
+            else if (ref !== undefined) {
+                ref.current = node;
+            }
+        }
+    };
+}
+function joinIds(...ids) {
+    const value = ids.filter((id) => id !== undefined && id !== "").join(" ");
+    return value.length > 0 ? value : undefined;
+}
+function getPlacementParts(placement) {
+    const [side, align = "center"] = placement.split("-");
+    return { side, align };
+}
+export function Tooltip({ children, content, delay = 0, disabled = false, placement = "bottom" }) {
+    const tooltipId = React.useId();
+    const tooltipElementId = `${tooltipId}-content`;
+    const [open, setOpen] = React.useState(false);
+    const openTimeoutRef = React.useRef(null);
+    const { floatingRef, floatingStyle, placement: resolvedPlacement, referenceRef, updatePosition } = useFloatingPosition({
+        open,
+        placement,
+        offset: 8,
+        flip: true,
+        shift: true
+    });
+    const clearOpenTimeout = React.useCallback(() => {
+        if (openTimeoutRef.current === null) {
+            return;
+        }
+        window.clearTimeout(openTimeoutRef.current);
+        openTimeoutRef.current = null;
+    }, []);
+    const openWithDelay = React.useCallback(() => {
+        if (disabled) {
+            return;
+        }
+        clearOpenTimeout();
+        if (delay > 0) {
+            openTimeoutRef.current = window.setTimeout(() => {
+                setOpen(true);
+            }, delay);
+            return;
+        }
+        setOpen(true);
+    }, [clearOpenTimeout, delay, disabled]);
+    const closeTooltip = React.useCallback(() => {
+        clearOpenTimeout();
+        setOpen(false);
+    }, [clearOpenTimeout]);
+    React.useEffect(() => {
+        if (!open) {
+            return;
+        }
+        updatePosition();
+    }, [open, content, updatePosition]);
+    React.useEffect(() => {
+        if (disabled) {
+            closeTooltip();
+        }
+    }, [closeTooltip, disabled]);
+    React.useEffect(() => () => clearOpenTimeout(), [clearOpenTimeout]);
+    if (!React.isValidElement(children) || disabled) {
+        return children;
+    }
+    const trigger = children;
+    const childProps = trigger.props;
+    const childAriaDescribedBy = childProps["aria-describedby"];
+    const triggerAriaDescribedBy = joinIds(typeof childAriaDescribedBy === "string" ? childAriaDescribedBy : undefined, open ? tooltipElementId : undefined);
+    const mergedRef = composeRefs(childProps.ref, referenceRef);
+    const placementParts = getPlacementParts(resolvedPlacement);
+    return (_jsxs(_Fragment, { children: [React.cloneElement(trigger, {
+                ...childProps,
+                ref: mergedRef,
+                "aria-describedby": triggerAriaDescribedBy,
+                onMouseEnter: composeEventHandlers(childProps.onMouseEnter, openWithDelay),
+                onPointerEnter: composeEventHandlers(childProps.onPointerEnter, openWithDelay),
+                onMouseLeave: composeEventHandlers(childProps.onMouseLeave, closeTooltip),
+                onPointerLeave: composeEventHandlers(childProps.onPointerLeave, closeTooltip),
+                onFocus: composeEventHandlers(childProps.onFocus, openWithDelay),
+                onBlur: composeEventHandlers(childProps.onBlur, closeTooltip),
+                onKeyDown: composeEventHandlers(childProps.onKeyDown, (event) => {
+                    if (event.key === "Escape") {
+                        closeTooltip();
+                    }
+                }, { checkDefaultPrevented: false })
+            }), open ? (_jsx(Portal, { children: _jsx("span", { id: tooltipElementId, className: "liano-tooltip", "data-align": placementParts.align, "data-side": placementParts.side, role: "tooltip", ref: floatingRef, style: floatingStyle, children: content }) })) : null] }));
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,7 @@
+export { useComposedRefs } from "./use-composed-refs.js";
+export type { LianoPossibleRef } from "./use-composed-refs.js";
+export { useControllableState } from "./use-controllable-state.js";
+export type { LianoSetStateAction, UseControllableStateOptions } from "./use-controllable-state.js";
+export { useDisclosure } from "./use-disclosure.js";
+export type { UseDisclosureOptions, UseDisclosureReturn } from "./use-disclosure.js";
+export { useEvent } from "./use-event.js";

package/dist/hooks/index.js

@@ -0,0 +1,5 @@
+"use client";
+export { useComposedRefs } from "./use-composed-refs.js";
+export { useControllableState } from "./use-controllable-state.js";
+export { useDisclosure } from "./use-disclosure.js";
+export { useEvent } from "./use-event.js";

package/dist/hooks/use-composed-refs.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+export type LianoPossibleRef<Value> = React.Ref<Value> | undefined;
+export declare function useComposedRefs<Value>(...refs: LianoPossibleRef<Value>[]): React.RefCallback<Value>;

package/dist/hooks/use-composed-refs.js

@@ -0,0 +1,18 @@
+"use client";
+import * as React from "react";
+function setRef(ref, value) {
+    if (typeof ref === "function") {
+        ref(value);
+        return;
+    }
+    if (ref) {
+        ref.current = value;
+    }
+}
+export function useComposedRefs(...refs) {
+    return React.useCallback((value) => {
+        for (const ref of refs) {
+            setRef(ref, value);
+        }
+    }, refs);
+}

package/dist/hooks/use-controllable-state.d.ts

@@ -0,0 +1,7 @@
+export type LianoSetStateAction<Value> = Value | ((previous: Value) => Value);
+export interface UseControllableStateOptions<Value> {
+    value?: Value;
+    defaultValue: Value;
+    onChange?: (value: Value) => void;
+}
+export declare function useControllableState<Value>({ value, defaultValue, onChange }: UseControllableStateOptions<Value>): readonly [Value, (next: LianoSetStateAction<Value>) => void];

package/dist/hooks/use-controllable-state.js

@@ -0,0 +1,30 @@
+"use client";
+import * as React from "react";
+import { useEvent } from "./use-event.js";
+export function useControllableState({ value, defaultValue, onChange }) {
+    const [internalValue, setInternalValue] = React.useState(defaultValue);
+    const handleChange = useEvent((nextValue) => {
+        onChange?.(nextValue);
+    });
+    const isControlled = value !== undefined;
+    const currentValue = isControlled ? value : internalValue;
+    const currentValueRef = React.useRef(currentValue);
+    React.useLayoutEffect(() => {
+        currentValueRef.current = currentValue;
+    }, [currentValue]);
+    const setValue = React.useCallback((next) => {
+        const previousValue = isControlled ? currentValue : currentValueRef.current;
+        const nextValue = typeof next === "function" ? next(previousValue) : next;
+        if (Object.is(nextValue, previousValue)) {
+            return;
+        }
+        if (isControlled) {
+            handleChange(nextValue);
+            return;
+        }
+        currentValueRef.current = nextValue;
+        setInternalValue(nextValue);
+        handleChange(nextValue);
+    }, [currentValue, handleChange, isControlled]);
+    return [currentValue, setValue];
+}

package/dist/hooks/use-disclosure.d.ts

@@ -0,0 +1,13 @@
+export interface UseDisclosureOptions {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export interface UseDisclosureReturn {
+    open: boolean;
+    setOpen: (open: boolean | ((previous: boolean) => boolean)) => void;
+    openDisclosure: () => void;
+    closeDisclosure: () => void;
+    toggleDisclosure: () => void;
+}
+export declare function useDisclosure({ open, defaultOpen, onOpenChange }?: UseDisclosureOptions): UseDisclosureReturn;

package/dist/hooks/use-disclosure.js

@@ -0,0 +1,20 @@
+"use client";
+import * as React from "react";
+import { useControllableState } from "./use-controllable-state.js";
+export function useDisclosure({ open, defaultOpen = false, onOpenChange } = {}) {
+    const [currentOpen, setOpen] = useControllableState({
+        ...(open !== undefined ? { value: open } : {}),
+        ...(onOpenChange ? { onChange: onOpenChange } : {}),
+        defaultValue: defaultOpen
+    });
+    const openDisclosure = React.useCallback(() => setOpen(true), [setOpen]);
+    const closeDisclosure = React.useCallback(() => setOpen(false), [setOpen]);
+    const toggleDisclosure = React.useCallback(() => setOpen((previous) => !previous), [setOpen]);
+    return {
+        open: currentOpen,
+        setOpen,
+        openDisclosure,
+        closeDisclosure,
+        toggleDisclosure
+    };
+}

package/dist/hooks/use-event.d.ts

@@ -0,0 +1 @@
+export declare function useEvent<Callback extends (...args: never[]) => unknown>(callback: Callback): Callback;

package/dist/hooks/use-event.js

@@ -0,0 +1,11 @@
+"use client";
+import * as React from "react";
+export function useEvent(callback) {
+    const callbackRef = React.useRef(callback);
+    React.useLayoutEffect(() => {
+        callbackRef.current = callback;
+    });
+    return React.useCallback(((...args) => {
+        return callbackRef.current(...args);
+    }), []);
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./components/index.js";
+export * from "./tokens/index.js";
+export * from "./utils/index.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./components/index.js";
+export * from "./tokens/index.js";
+export * from "./utils/index.js";

package/dist/internal/collection/collection.d.ts

@@ -0,0 +1,18 @@
+export interface CollectionItem<ItemData> {
+    id: string;
+    data: ItemData;
+}
+export interface Collection<ItemData extends {
+    disabled?: boolean | undefined;
+}> {
+    firstEnabled: () => CollectionItem<ItemData> | undefined;
+    items: () => Array<CollectionItem<ItemData>>;
+    lastEnabled: () => CollectionItem<ItemData> | undefined;
+    nextEnabled: (id: string | undefined) => CollectionItem<ItemData> | undefined;
+    previousEnabled: (id: string | undefined) => CollectionItem<ItemData> | undefined;
+    register: (id: string, data: ItemData) => void;
+    unregister: (id: string) => void;
+}
+export declare function createCollection<ItemData extends {
+    disabled?: boolean | undefined;
+}>(): Collection<ItemData>;

package/dist/internal/collection/collection.js

@@ -0,0 +1,54 @@
+function enabledItems(items) {
+    return items.filter((item) => item.data.disabled !== true);
+}
+function wrapIndex(index, length) {
+    return ((index % length) + length) % length;
+}
+export function createCollection() {
+    const order = [];
+    const records = new Map();
+    const items = () => order
+        .map((id) => {
+        const data = records.get(id);
+        return data === undefined ? undefined : { id, data };
+    })
+        .filter((item) => item !== undefined);
+    const firstEnabled = () => enabledItems(items())[0];
+    const lastEnabled = () => enabledItems(items()).at(-1);
+    const nextEnabled = (id) => {
+        const enabled = enabledItems(items());
+        if (enabled.length === 0) {
+            return undefined;
+        }
+        const currentIndex = id === undefined ? -1 : enabled.findIndex((item) => item.id === id);
+        return enabled[wrapIndex(currentIndex + 1, enabled.length)];
+    };
+    const previousEnabled = (id) => {
+        const enabled = enabledItems(items());
+        if (enabled.length === 0) {
+            return undefined;
+        }
+        const currentIndex = id === undefined ? 0 : enabled.findIndex((item) => item.id === id);
+        return enabled[wrapIndex(currentIndex - 1, enabled.length)];
+    };
+    return {
+        firstEnabled,
+        items,
+        lastEnabled,
+        nextEnabled,
+        previousEnabled,
+        register: (id, data) => {
+            if (!order.includes(id)) {
+                order.push(id);
+            }
+            records.set(id, data);
+        },
+        unregister: (id) => {
+            records.delete(id);
+            const index = order.indexOf(id);
+            if (index >= 0) {
+                order.splice(index, 1);
+            }
+        }
+    };
+}

package/dist/internal/collection/index.d.ts

@@ -0,0 +1,2 @@
+export { createCollection } from "./collection.js";
+export type { Collection, CollectionItem } from "./collection.js";

package/dist/internal/collection/index.js

@@ -0,0 +1 @@
+export { createCollection } from "./collection.js";

package/dist/internal/dismissable-layer/dismissable-layer.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+export interface DismissableLayerProps {
+    children: React.ReactNode;
+    open?: boolean;
+    modal?: boolean;
+    disableOutsidePointerDown?: boolean;
+    disableEscapeKeyDown?: boolean;
+    onDismiss?: (event: Event) => void;
+    onEscapeKeyDown?: (event: Event) => void;
+    onPointerDownOutside?: (event: Event) => void;
+}
+export declare function DismissableLayer({ children, open, disableOutsidePointerDown, disableEscapeKeyDown, onDismiss, onEscapeKeyDown, onPointerDownOutside }: DismissableLayerProps): React.ReactElement | null;
+export default DismissableLayer;

package/dist/internal/dismissable-layer/dismissable-layer.js

@@ -0,0 +1,73 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { isTopOverlay, popOverlay, pushOverlay } from "../overlay-stack/overlay-stack.js";
+export function DismissableLayer({ children, open = true, disableOutsidePointerDown = false, disableEscapeKeyDown = false, onDismiss, onEscapeKeyDown, onPointerDownOutside }) {
+    const layerRef = React.useRef(null);
+    const idRef = React.useRef("");
+    React.useEffect(() => {
+        if (!open || layerRef.current === null) {
+            return;
+        }
+        const id = pushOverlay(layerRef.current);
+        idRef.current = id;
+        return () => {
+            popOverlay(id);
+            idRef.current = "";
+        };
+    }, [open]);
+    React.useEffect(() => {
+        if (!open || layerRef.current === null) {
+            return;
+        }
+        const handlePointerDown = (event) => {
+            if (disableOutsidePointerDown) {
+                return;
+            }
+            if (!isTopOverlay(idRef.current)) {
+                return;
+            }
+            const target = event.target;
+            if (target && layerRef.current?.contains(target)) {
+                return;
+            }
+            const insideEvent = new CustomEvent("pointerdownoutside", {
+                bubbles: false,
+                cancelable: true,
+                detail: event
+            });
+            onPointerDownOutside?.(insideEvent);
+            if (!insideEvent.defaultPrevented) {
+                onDismiss?.(insideEvent);
+            }
+        };
+        const handleKeyDown = (event) => {
+            if (event.key !== "Escape" || disableEscapeKeyDown) {
+                return;
+            }
+            if (!isTopOverlay(idRef.current)) {
+                return;
+            }
+            const escapeEvent = new CustomEvent("escape", {
+                bubbles: false,
+                cancelable: true,
+                detail: event
+            });
+            onEscapeKeyDown?.(escapeEvent);
+            if (!escapeEvent.defaultPrevented) {
+                onDismiss?.(escapeEvent);
+            }
+        };
+        document.addEventListener("pointerdown", handlePointerDown, true);
+        document.addEventListener("keydown", handleKeyDown, true);
+        return () => {
+            document.removeEventListener("pointerdown", handlePointerDown, true);
+            document.removeEventListener("keydown", handleKeyDown, true);
+        };
+    }, [disableEscapeKeyDown, disableOutsidePointerDown, onDismiss, onEscapeKeyDown, onPointerDownOutside, open]);
+    if (!open) {
+        return null;
+    }
+    return _jsx("div", { ref: layerRef, children: children });
+}
+export default DismissableLayer;

package/dist/internal/dismissable-layer/index.d.ts

@@ -0,0 +1,2 @@
+export { DismissableLayer } from "./dismissable-layer.js";
+export type { DismissableLayerProps } from "./dismissable-layer.js";

package/dist/internal/dismissable-layer/index.js

@@ -0,0 +1 @@
+export { DismissableLayer } from "./dismissable-layer.js";

package/dist/internal/floating/auto-update.d.ts

@@ -0,0 +1,9 @@
+export type AutoUpdateStopListening = () => void;
+interface AutoUpdateParams {
+    enabled: boolean;
+    reference: HTMLElement | null;
+    floating: HTMLElement | null;
+    update: () => void;
+}
+export declare function autoUpdateFloating(params: AutoUpdateParams): AutoUpdateStopListening;
+export {};

package/dist/internal/floating/auto-update.js

@@ -0,0 +1,48 @@
+function hasBrowserApis() {
+    return typeof window !== "undefined" && typeof document !== "undefined";
+}
+export function autoUpdateFloating(params) {
+    const { enabled, reference, floating, update } = params;
+    if (!hasBrowserApis() || !enabled || reference === null || floating === null) {
+        return () => { };
+    }
+    let frameRequest = null;
+    const scheduleUpdate = () => {
+        if (frameRequest !== null) {
+            cancelAnimationFrame(frameRequest);
+        }
+        frameRequest = window.requestAnimationFrame(() => {
+            frameRequest = null;
+            update();
+        });
+    };
+    const cleanupFns = [];
+    const handleScroll = () => {
+        scheduleUpdate();
+    };
+    const handleResize = () => {
+        scheduleUpdate();
+    };
+    const observer = typeof ResizeObserver !== "undefined" ? new ResizeObserver(scheduleUpdate) : null;
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    window.addEventListener("resize", handleResize);
+    cleanupFns.push(() => {
+        window.removeEventListener("scroll", handleScroll);
+        window.removeEventListener("resize", handleResize);
+    });
+    observer?.observe(reference);
+    observer?.observe(floating);
+    cleanupFns.push(() => {
+        observer?.disconnect();
+    });
+    scheduleUpdate();
+    return () => {
+        for (const cleanup of cleanupFns) {
+            cleanup();
+        }
+        if (frameRequest !== null) {
+            cancelAnimationFrame(frameRequest);
+            frameRequest = null;
+        }
+    };
+}

package/dist/internal/floating/compute-position.d.ts

@@ -0,0 +1,2 @@
+import type { FloatingPositionInput, FloatingPositionResult } from "./floating-types.js";
+export declare function computeFloatingPosition(options: FloatingPositionInput): FloatingPositionResult;

package/dist/internal/floating/compute-position.js

@@ -0,0 +1,96 @@
+import { clamp, getOppositeSide, parsePlacement, buildPlacement } from "./middleware.js";
+import { detectOverflow } from "./detect-overflow.js";
+function getCenteredOffset(referenceSize, floatingSize) {
+    return (referenceSize - floatingSize) / 2;
+}
+function getPlacementCoords(placement, reference, floating, offset) {
+    const { side, align } = parsePlacement(placement);
+    if (side === "top" || side === "bottom") {
+        const baseY = side === "top" ? reference.y - floating.height - offset : reference.y + reference.height + offset;
+        let x = reference.x;
+        if (align === "start") {
+            x = reference.x;
+        }
+        else if (align === "end") {
+            x = reference.x + reference.width - floating.width;
+        }
+        else {
+            x = reference.x + getCenteredOffset(reference.width, floating.width);
+        }
+        return { x, y: baseY };
+    }
+    const baseX = side === "left" ? reference.x - floating.width - offset : reference.x + reference.width + offset;
+    let y = reference.y;
+    if (align === "start") {
+        y = reference.y;
+    }
+    else if (align === "end") {
+        y = reference.y + reference.height - floating.height;
+    }
+    else {
+        y = reference.y + getCenteredOffset(reference.height, floating.height);
+    }
+    return { x: baseX, y };
+}
+function getOverflowForPlacement(placement, reference, floating, boundary, offset, collisionPadding) {
+    const { x, y } = getPlacementCoords(placement, reference, floating, offset);
+    return detectOverflow({
+        boundary,
+        collisionPadding,
+        floatingRect: {
+            x,
+            y,
+            width: floating.width,
+            height: floating.height
+        }
+    });
+}
+export function computeFloatingPosition(options) {
+    const { reference, floating, boundary, placement: rawPlacement = "bottom", strategy = "absolute", offset = 0, collisionPadding = 0, matchReferenceWidth = false, maxHeight, flip = true, shift = true } = options;
+    const parsed = parsePlacement(rawPlacement);
+    const defaultPlacement = buildPlacement(parsed.side, parsed.align);
+    let currentPlacement = defaultPlacement;
+    let basePlacement = getPlacementCoords(currentPlacement, reference, floating, offset);
+    if (flip) {
+        const overflow = getOverflowForPlacement(currentPlacement, reference, floating, boundary, offset, collisionPadding);
+        const { side: currentSide } = parsePlacement(currentPlacement);
+        const overflowSide = overflow[currentSide];
+        if (overflowSide > 0) {
+            const oppositeSide = getOppositeSide(currentSide);
+            const oppositePlacement = buildPlacement(oppositeSide, parsed.align);
+            const oppositeOverflow = getOverflowForPlacement(oppositePlacement, reference, floating, boundary, offset, collisionPadding);
+            if (oppositeOverflow[oppositeSide] < overflowSide) {
+                currentPlacement = oppositePlacement;
+                basePlacement = getPlacementCoords(currentPlacement, reference, floating, offset);
+            }
+        }
+    }
+    let x = basePlacement.x;
+    let y = basePlacement.y;
+    if (shift) {
+        const { side } = parsePlacement(currentPlacement);
+        if (side === "top" || side === "bottom") {
+            x = clamp(x, boundary.x + collisionPadding, boundary.x + boundary.width - collisionPadding - floating.width);
+        }
+        else {
+            y = clamp(y, boundary.y + collisionPadding, boundary.y + boundary.height - collisionPadding - floating.height);
+        }
+    }
+    const rawAvailableWidth = Math.max(0, boundary.width - collisionPadding * 2);
+    const rawAvailableHeight = Math.max(0, boundary.height - collisionPadding * 2);
+    const availableWidth = matchReferenceWidth
+        ? Math.min(rawAvailableWidth, reference.width)
+        : rawAvailableWidth;
+    const constrainedHeight = Math.max(0, rawAvailableHeight);
+    const availableHeight = Math.min(constrainedHeight, maxHeight === undefined ? constrainedHeight : maxHeight);
+    return {
+        x,
+        y,
+        placement: currentPlacement,
+        strategy,
+        availableWidth,
+        availableHeight,
+        referenceWidth: reference.width,
+        referenceHeight: reference.height
+    };
+}

package/dist/internal/floating/detect-overflow.d.ts

@@ -0,0 +1,13 @@
+import type { FloatingBoundary, FloatingRect } from "./floating-types.js";
+export interface FloatingOverflow {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface OverflowInput {
+    boundary: FloatingBoundary;
+    floatingRect: FloatingRect;
+    collisionPadding: number;
+}
+export declare function detectOverflow(input: OverflowInput): FloatingOverflow;

package/dist/internal/floating/detect-overflow.js

@@ -0,0 +1,13 @@
+export function detectOverflow(input) {
+    const { boundary, floatingRect, collisionPadding } = input;
+    const minX = boundary.x + collisionPadding;
+    const maxX = boundary.x + boundary.width - collisionPadding;
+    const minY = boundary.y + collisionPadding;
+    const maxY = boundary.y + boundary.height - collisionPadding;
+    return {
+        top: Math.max(0, minY - floatingRect.y),
+        left: Math.max(0, minX - floatingRect.x),
+        right: Math.max(0, floatingRect.x + floatingRect.width - maxX),
+        bottom: Math.max(0, floatingRect.y + floatingRect.height - maxY)
+    };
+}

package/dist/internal/floating/floating-types.d.ts

@@ -0,0 +1,42 @@
+export type FloatingSide = "top" | "right" | "bottom" | "left";
+export type FloatingAlign = "start" | "center" | "end";
+export type FloatingPlacement = FloatingSide | `${FloatingSide}-${Exclude<FloatingAlign, "center">}`;
+export type FloatingStrategy = "absolute" | "fixed";
+export interface FloatingRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface FloatingBoundary {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ComputeFloatingPositionOptions {
+    placement?: FloatingPlacement;
+    strategy?: FloatingStrategy;
+    offset?: number;
+    collisionPadding?: number;
+    matchReferenceWidth?: boolean;
+    maxHeight?: number;
+    flip?: boolean;
+    shift?: boolean;
+    boundary?: FloatingBoundary;
+}
+export interface FloatingPositionInput extends ComputeFloatingPositionOptions {
+    reference: FloatingRect;
+    floating: FloatingRect;
+    boundary: FloatingBoundary;
+}
+export interface FloatingPositionResult {
+    x: number;
+    y: number;
+    placement: FloatingPlacement;
+    strategy: FloatingStrategy;
+    availableWidth: number;
+    availableHeight: number;
+    referenceWidth: number;
+    referenceHeight: number;
+}

package/dist/internal/floating/floating-types.js

@@ -0,0 +1 @@
+export {};