@actview/floating-ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @floating-ui/actview — @floating-ui/react 的 actview 版。
+ *
+ * 导出面与 upstream `packages/react/src/index.ts` 对齐：
+ * - utils 工具（`./utils` 子路径同 `@floating-ui/react/utils`）
+ * - 交互 hooks（useClick / useDismiss / useHover / useListNavigation / ...）
+ * - 组件（FloatingTree / FloatingPortal / FloatingFocusManager / Composite / ...）
+ * - safePolygon / inner / useInnerOffset
+ */
+export { Composite, CompositeItem } from './components/Composite';
+export { FloatingArrow } from './components/FloatingArrow';
+export { FloatingDelayGroup, useDelayGroup, useDelayGroupContext, } from './components/FloatingDelayGroup';
+export { NextFloatingDelayGroup, useNextDelayGroup, } from './components/NextFloatingDelayGroup';
+export { FloatingFocusManager } from './components/FloatingFocusManager';
+export { FloatingList, useListItem } from './components/FloatingList';
+export { FloatingOverlay } from './components/FloatingOverlay';
+export { FloatingPortal, useFloatingPortalNode, } from './components/FloatingPortal';
+export { FloatingNode, FloatingTree, useFloatingNodeId, useFloatingParentNodeId, useFloatingTree, } from './components/FloatingTree';
+export { useClick } from './hooks/useClick';
+export { useClientPoint } from './hooks/useClientPoint';
+export { useDismiss } from './hooks/useDismiss';
+export { useFloating } from './hooks/useFloating';
+export { useFloatingRootContext } from './hooks/useFloatingRootContext';
+export { useFocus } from './hooks/useFocus';
+export { useHover } from './hooks/useHover';
+export { useId } from './hooks/useId';
+export { useInteractions } from './hooks/useInteractions';
+export { useListNavigation } from './hooks/useListNavigation';
+export { gridNavigation } from './hooks/gridNavigation';
+export { useMergeRefs } from './hooks/useMergeRefs';
+export { useRole } from './hooks/useRole';
+export { useTransitionStatus, useTransitionStyles } from './hooks/useTransition';
+export { useTypeahead } from './hooks/useTypeahead';
+export { inner, useInnerOffset } from './_deprecated-inner';
+export { safePolygon } from './safePolygon';
+export type * from './types';
+export * from './utils';

package/dist/safePolygon.d.ts

@@ -0,0 +1,12 @@
+import type { HandleClose } from './hooks/useHover';
+export interface SafePolygonOptions {
+    buffer?: number | undefined;
+    blockPointerEvents?: boolean | undefined;
+    requireIntent?: boolean | undefined;
+}
+/**
+ * Generates a safe polygon area that the user can traverse without closing the
+ * floating element once leaving the reference element.
+ * @see https://floating-ui.com/docs/useHover#safepolygon
+ */
+export declare function safePolygon(options?: SafePolygonOptions): HandleClose;

package/dist/types.d.ts

@@ -0,0 +1,140 @@
+/**
+ * @floating-ui/actview — 第一阶段类型子集。
+ *
+ * 只包含 utils 层（nodes.ts / composite.ts）实际引用的类型；
+ * hooks/components 阶段将按 upstream `packages/react/src/types.ts` 逐步补全。
+ *
+ * 与 upstream 的差异：
+ * - `React.MutableRefObject<T>` → actview 框架类型 `Ref<T>`（来自 @actview/core，只能读 .value）
+ * - `UsePositionFloatingReturn` 为最小结构（upstream 从 @floating-ui/react-dom 导入，
+ *   actview 在 hooks 阶段实现 useFloating 时补全）
+ */
+import type { Ref } from '@actview/core';
+import type { Dimensions, Middleware, MiddlewareData, Placement, Platform, Rect, Side, Strategy, VirtualElement } from '@floating-ui/dom';
+export type { Dimensions, Middleware, Placement, Rect, Side };
+export type { SafePolygonOptions } from './safePolygon';
+export type Delay = number | Partial<{
+    open: number | undefined;
+    close: number | undefined;
+}>;
+export type Alignment = 'start' | 'end';
+export type ReferenceType = Element | VirtualElement;
+export type NarrowedElement<T> = T extends Element ? T : Element;
+export interface FloatingEvents {
+    emit<T extends string>(event: T, data?: any): void;
+    on(event: string, handler: (data: any) => void): void;
+    off(event: string, handler: (data: any) => void): void;
+}
+export interface ContextData {
+    openEvent?: Event | undefined;
+    floatingContext?: FloatingContext | undefined;
+    /** @deprecated use `onTypingChange` prop in `useTypeahead` */
+    typing?: boolean | undefined;
+    [key: string]: any;
+}
+/**
+ * 定位返回值子集（upstream 来自 @floating-ui/react-dom 的 UsePositionFloatingReturn）。
+ * actview 版响应式字段为 `Ref<T>`（.value），hooks 阶段实现 useFloating 时补全。
+ */
+export interface UsePositionFloatingReturn {
+    x: Ref<number | null>;
+    y: Ref<number | null>;
+    placement: Ref<Placement>;
+    strategy: Ref<Strategy>;
+    middlewareData: Ref<MiddlewareData>;
+    isPositioned: Ref<boolean>;
+    update(): void;
+    floatingStyles: Ref<Record<string, string | number>>;
+}
+export interface ExtendedRefs<RT extends ReferenceType = ReferenceType> {
+    reference: Ref<ReferenceType | null>;
+    floating: Ref<HTMLElement | null>;
+    domReference: Ref<NarrowedElement<RT> | null>;
+    setReference(node: RT | null): void;
+    setFloating(node: HTMLElement | null): void;
+    setPositionReference(node: ReferenceType | null): void;
+}
+export interface ExtendedElements<RT extends ReferenceType = ReferenceType> {
+    reference: Ref<ReferenceType | null>;
+    floating: Ref<HTMLElement | null>;
+    domReference: Ref<Element | null>;
+}
+export type OpenChangeReason = 'outside-press' | 'escape-key' | 'ancestor-scroll' | 'reference-press' | 'click' | 'hover' | 'focus' | 'focus-out' | 'list-navigation' | 'safe-polygon';
+export interface FloatingRootContext<RT extends ReferenceType = ReferenceType> {
+    dataRef: Ref<ContextData>;
+    open: Ref<boolean>;
+    onOpenChange(open: boolean, event?: Event, reason?: OpenChangeReason): void;
+    elements: {
+        domReference: Ref<Element | null>;
+        reference: Ref<RT | null>;
+        floating: Ref<HTMLElement | null>;
+    };
+    events: FloatingEvents;
+    floatingId: Ref<string | undefined>;
+    refs: {
+        setPositionReference(node: ReferenceType | null): void;
+    };
+}
+export type FloatingContext<RT extends ReferenceType = ReferenceType> = Omit<UsePositionFloatingReturn, 'refs' | 'elements'> & {
+    open: Ref<boolean>;
+    onOpenChange(open: boolean, event?: Event, reason?: OpenChangeReason): void;
+    events: FloatingEvents;
+    dataRef: Ref<ContextData>;
+    nodeId: Ref<string | undefined>;
+    floatingId: Ref<string | undefined>;
+    refs: ExtendedRefs<RT>;
+    elements: ExtendedElements<RT>;
+};
+export interface FloatingNodeType<RT extends ReferenceType = ReferenceType> {
+    id: string | undefined;
+    parentId: string | null;
+    context?: FloatingContext<RT> | undefined;
+}
+export interface FloatingTreeType<RT extends ReferenceType = ReferenceType> {
+    nodesRef: Ref<Array<FloatingNodeType<RT>>>;
+    events: FloatingEvents;
+    addNode(node: FloatingNodeType): void;
+    removeNode(node: FloatingNodeType): void;
+}
+/**
+ * `useFloating` 的选项（upstream 拆分自 @floating-ui/react-dom 的
+ * UseFloatingOptions 与 react 包的扩展）。
+ * actview 版：`open` / `nodeId` 支持 `Ref<T> | 值`；`rootContext` 可外部注入。
+ */
+export interface UseFloatingOptions<RT extends ReferenceType = ReferenceType> {
+    open?: boolean | Ref<boolean> | undefined;
+    onOpenChange?: ((open: boolean, event?: Event, reason?: OpenChangeReason) => void) | undefined;
+    placement?: Placement | undefined;
+    strategy?: Strategy | undefined;
+    middleware?: Array<Middleware> | undefined;
+    platform?: Platform | undefined;
+    transform?: boolean | undefined;
+    whileElementsMounted?: ((reference: RT, floating: HTMLElement, update: () => void) => () => void) | undefined;
+    elements?: {
+        reference?: RT | null | undefined;
+        floating?: HTMLElement | null | undefined;
+    } | undefined;
+    rootContext?: FloatingRootContext<RT> | undefined;
+    nodeId?: string | Ref<string | undefined> | undefined;
+}
+export type UseFloatingReturn<RT extends ReferenceType = ReferenceType> = UsePositionFloatingReturn & {
+    context: FloatingContext<RT>;
+    refs: ExtendedRefs<RT>;
+    elements: ExtendedElements<RT>;
+};
+/** 事件处理器 props 中用于标记 active/selected 的自定义键（ACTIVE_KEY / SELECTED_KEY） */
+export type ExtendedUserProps = {
+    active?: boolean | undefined;
+    selected?: boolean | undefined;
+};
+/**
+ * 交互 hook（useClick / useHover / useDismiss / useListNavigation 等）返回的
+ * 事件处理器集合，由调用方 spread 到 reference / floating / item 元素上。
+ * reference / floating 可为 `Ref`（响应式派生，如 useRole 的 aria 属性随 open 变化）；
+ * mergeProps 用 `unref` 统一解包。item 的函数形态按调用传入的 active/selected 派生。
+ */
+export interface ElementProps {
+    reference?: Record<string, unknown> | Ref<Record<string, unknown>> | undefined;
+    floating?: Record<string, unknown> | Ref<Record<string, unknown>> | undefined;
+    item?: Record<string, unknown> | Ref<Record<string, unknown>> | ((props: ExtendedUserProps) => Record<string, unknown>) | undefined;
+}

package/dist/useFloating.d.ts

@@ -0,0 +1,57 @@
+import { type Ref } from '@actview/core';
+import { type Middleware, type MiddlewareData, type Placement, type Platform, type Strategy } from '@floating-ui/dom';
+import type { ReferenceType } from './types';
+/**
+ * 定位核心（upstream 为 @floating-ui/react-dom 的 useFloating）。
+ *
+ * 与 upstream 的差异：
+ * - 无 React：状态（x / y / placement / strategy / middlewareData / isPositioned）
+ *   为 `Ref<T>`，update 结果直接赋值（actview 依赖追踪自动触发渲染）
+ * - 无 `ReactDOM.flushSync`（actview 自行调度渲染）
+ * - `useModernLayoutEffect` → `watch`（referenceEl / floatingEl 变化时定位 +
+ *   whileElementsMounted 管理，immediate 首跑）
+ * - `open` 支持 `Ref<boolean> | boolean`（`isPositioned` 同步）
+ * - `elements.reference` / `elements.floating` 支持 `Ref`（toValue 读取）
+ * - 元素/引用统一用宽类型 `ReferenceType`（定位层面无需 RT 细分，
+ *   `computePosition` 接受 Element | VirtualElement）
+ * - `middleware` 固定（setup 一次），无需 latestMiddleware 状态
+ * - `floatingStyles` 为 `computed`（`Record<string, string | number>`）
+ */
+export interface UseFloatingOptions {
+    placement?: Placement | undefined;
+    strategy?: Strategy | undefined;
+    middleware?: Array<Middleware> | undefined;
+    platform?: Platform | undefined;
+    elements?: {
+        reference?: ReferenceType | null | Ref<ReferenceType | null> | undefined;
+        floating?: HTMLElement | null | Ref<HTMLElement | null> | undefined;
+    } | undefined;
+    transform?: boolean | undefined;
+    whileElementsMounted?: ((reference: ReferenceType, floating: HTMLElement, update: () => void) => () => void) | undefined;
+    open?: boolean | Ref<boolean> | undefined;
+}
+export interface UseFloatingReturn {
+    x: Ref<number | null>;
+    y: Ref<number | null>;
+    strategy: Ref<Strategy>;
+    placement: Ref<Placement>;
+    middlewareData: Ref<MiddlewareData>;
+    isPositioned: Ref<boolean>;
+    update(): void;
+    floatingStyles: Ref<Record<string, string | number>>;
+    refs: {
+        reference: Ref<ReferenceType | null>;
+        floating: Ref<HTMLElement | null>;
+        setReference(node: ReferenceType | null): void;
+        setFloating(node: HTMLElement | null): void;
+    };
+    elements: {
+        reference: Ref<ReferenceType | null>;
+        floating: Ref<HTMLElement | null>;
+    };
+}
+/**
+ * Provides data to position a floating element.
+ * @see https://floating-ui.com/docs/useFloating
+ */
+export declare function useFloating(options?: UseFloatingOptions): UseFloatingReturn;

package/dist/utils/clearTimeoutIfSet.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from '@actview/core';
+export declare function clearTimeoutIfSet(timeoutRef: Ref<number>): void;

package/dist/utils/composite.d.ts

@@ -0,0 +1,41 @@
+import type { Ref } from '@actview/core';
+import type { Dimensions } from '../types';
+type ListRef = Ref<Array<HTMLElement | null>>;
+interface KeyboardEventLike {
+    key: string;
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+export type DisabledIndices = Array<number> | ((index: number) => boolean);
+export declare function isDifferentGridRow(index: number, cols: number, prevRow: number): boolean;
+export declare function isIndexOutOfListBounds(listRef: ListRef, index: number): boolean;
+export declare function getMinListIndex(listRef: ListRef, disabledIndices?: DisabledIndices | undefined): number;
+export declare function getMaxListIndex(listRef: ListRef, disabledIndices?: DisabledIndices | undefined): number;
+export declare function findNonDisabledListIndex(listRef: ListRef, { startingIndex, decrement, disabledIndices, amount, }?: {
+    startingIndex?: number | undefined;
+    decrement?: boolean | undefined;
+    disabledIndices?: DisabledIndices | undefined;
+    amount?: number | undefined;
+}): number;
+export declare function getGridNavigatedIndex(listRef: ListRef, { event, orientation, loop, rtl, cols, disabledIndices, minIndex, maxIndex, prevIndex, stopEvent: stop, }: {
+    event: KeyboardEventLike;
+    orientation: 'horizontal' | 'vertical' | 'both';
+    loop: boolean;
+    rtl: boolean;
+    cols: number;
+    disabledIndices: DisabledIndices | undefined;
+    minIndex: number;
+    maxIndex: number;
+    prevIndex: number;
+    stopEvent?: boolean | undefined;
+}): number;
+/** For each cell index, gets the item index that occupies that cell */
+export declare function createGridCellMap(sizes: Dimensions[], cols: number, dense: boolean): (number | undefined)[];
+/** Gets cell index of an item's corner or -1 when index is -1. */
+export declare function getGridCellIndexOfCorner(index: number, sizes: Dimensions[], cellMap: (number | undefined)[], cols: number, corner: 'tl' | 'tr' | 'bl' | 'br'): number;
+/** Gets all cell indices that correspond to the specified indices */
+export declare function getGridCellIndices(indices: (number | undefined)[], cellMap: (number | undefined)[]): number[];
+export declare function isListIndexDisabled(listRef: ListRef, index: number, disabledIndices?: DisabledIndices): boolean;
+export declare function isHiddenByStyles(styles: CSSStyleDeclaration): boolean;
+export declare function isElementVisible(element: Element | null, styles?: CSSStyleDeclaration | null): boolean;
+export {};

package/dist/utils/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const FOCUSABLE_ATTRIBUTE = "data-floating-ui-focusable";
+export declare const ACTIVE_KEY = "active";
+export declare const SELECTED_KEY = "selected";
+export declare const TYPEABLE_SELECTOR: string;
+export declare const ARROW_LEFT = "ArrowLeft";
+export declare const ARROW_RIGHT = "ArrowRight";
+export declare const ARROW_UP = "ArrowUp";
+export declare const ARROW_DOWN = "ArrowDown";

package/dist/utils/createAttribute.d.ts

@@ -0,0 +1 @@
+export declare function createAttribute(name: string): string;

package/dist/utils/createEventEmitter.d.ts

@@ -0,0 +1,5 @@
+export declare function createEventEmitter(): {
+    emit(event: string, data: any): void;
+    on(event: string, listener: (data: any) => void): void;
+    off(event: string, listener: (data: any) => void): void;
+};

package/dist/utils/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(a: any, b: any): boolean;

package/dist/utils/element.d.ts

@@ -0,0 +1,10 @@
+export declare function activeElement(doc: Document): Element | null;
+export declare function contains(parent?: Element | null, child?: Element | null): boolean;
+export declare function getTarget(event: Event): EventTarget | null;
+export declare function isEventTargetWithin(event: Event, node: Node | null | undefined): boolean;
+export declare function isRootElement(element: Element): boolean;
+export declare function getDocument(node: Element | null): Document;
+export declare function isTypeableElement(element: unknown): boolean;
+export declare function isTypeableCombobox(element: Element | null): boolean;
+export declare function matchesFocusVisible(element: Element | null): boolean;
+export declare function getFloatingFocusElement(floatingElement: HTMLElement | null | undefined): HTMLElement | null;

package/dist/utils/enqueueFocus.d.ts

@@ -0,0 +1,8 @@
+import type { FocusableElement } from 'tabbable';
+interface Options {
+    preventScroll?: boolean | undefined;
+    cancelPrevious?: boolean | undefined;
+    sync?: boolean | undefined;
+}
+export declare function enqueueFocus(el: FocusableElement | null, options?: Options): void;
+export {};

package/dist/utils/event.d.ts

@@ -0,0 +1,10 @@
+export interface SyntheticEventLike {
+    preventDefault(): void;
+    stopPropagation(): void;
+    nativeEvent?: unknown;
+}
+export declare function stopEvent(event: Event | SyntheticEventLike): void;
+export declare function isReactEvent(event: any): event is SyntheticEventLike;
+export declare function isVirtualClick(event: MouseEvent | PointerEvent): boolean;
+export declare function isVirtualPointerEvent(event: PointerEvent): boolean;
+export declare function isMouseLikePointerType(pointerType: string | undefined, strict?: boolean): boolean;

package/dist/utils/getDPR.d.ts

@@ -0,0 +1 @@
+export declare function getDPR(element: Element): number;

package/dist/utils/hooks.d.ts

@@ -0,0 +1,16 @@
+import { type Ref } from '@actview/core';
+/**
+ * actview 版（upstream 为 React hooks：useLatestRef / useEffectEvent）。
+ *
+ * 与 upstream 的差异：
+ * - ref 为 actview 框架类型 `Ref<T>`（.value，非 React 的 .current），创建用 `ref()`
+ * - actview 无渲染循环与 effect 概念（setup 只执行一次、render 闭包每次渲染执行）——
+ *   `useLatestRef` 每次调用返回新的 `ref()`（引用稳定性由调用方负责）
+ * - `useEffectEvent` 无 useInsertionEffect 概念：回调在调用时同步写入 ref，
+ *   返回的稳定闭包始终调用最新回调。
+ * - `useModernLayoutEffect` 不再导出（React 专属，actview 无 layout effect）。
+ */
+export declare function useLatestRef<T>(value: T): Ref<T>;
+type AnyFunction = (...args: any[]) => any;
+export declare function useEffectEvent<T extends AnyFunction>(callback?: T): T;
+export {};

package/dist/utils/log.d.ts

@@ -0,0 +1,2 @@
+export declare function warn(...messages: string[]): void;
+export declare function error(...messages: string[]): void;

package/dist/utils/markOthers.d.ts

@@ -0,0 +1,4 @@
+type Undo = () => void;
+export declare const supportsInert: () => boolean;
+export declare function markOthers(avoidElements: Element[], ariaHidden?: boolean, inert?: boolean): Undo;
+export {};

package/dist/utils/nodes.d.ts

@@ -0,0 +1,4 @@
+import type { ReferenceType, FloatingNodeType } from '../types';
+export declare function getNodeChildren<RT extends ReferenceType = ReferenceType>(nodes: Array<FloatingNodeType<RT>>, id: string | undefined, onlyOpenChildren?: boolean): Array<FloatingNodeType<RT>>;
+export declare function getDeepestNode<RT extends ReferenceType = ReferenceType>(nodes: Array<FloatingNodeType<RT>>, id: string | undefined): FloatingNodeType<RT> | undefined;
+export declare function getNodeAncestors<RT extends ReferenceType = ReferenceType>(nodes: Array<FloatingNodeType<RT>>, id: string | undefined): FloatingNodeType<RT>[];

package/dist/utils/platform.d.ts

@@ -0,0 +1,6 @@
+export declare function getPlatform(): string;
+export declare function getUserAgent(): string;
+export declare function isSafari(): boolean;
+export declare function isAndroid(): boolean;
+export declare function isMac(): boolean;
+export declare function isJSDOM(): boolean;

package/dist/utils/roundByDPR.d.ts

@@ -0,0 +1 @@
+export declare function roundByDPR(element: Element, value: number): number;

package/dist/utils/safeReact.d.ts

@@ -0,0 +1,8 @@
+/**
+ * actview 占位（upstream: `export const SafeReact = {...React}`，
+ * https://github.com/mui/material-ui/issues/41190 —— useInsertionEffect shim）。
+ *
+ * actview 无 React / useInsertionEffect 概念，此文件保留以对齐 upstream 结构；
+ * 无消费者（actview 版 hooks.ts 不引用 SafeReact）。
+ */
+export declare const SafeReact: never;

package/dist/utils/tabbable.d.ts

@@ -0,0 +1,13 @@
+import { type FocusableElement } from 'tabbable';
+export declare const getTabbableOptions: () => {
+    readonly getShadowRoot: true;
+    readonly displayCheck: "none" | "full";
+};
+export declare function getNextTabbable(referenceElement: Element | null): FocusableElement | null;
+export declare function getPreviousTabbable(referenceElement: Element | null): FocusableElement | null;
+export declare function isOutsideEvent(event: FocusEvent | {
+    relatedTarget?: EventTarget | null;
+    currentTarget: EventTarget | null;
+}, container?: Element): boolean;
+export declare function disableFocusInside(container: HTMLElement): void;
+export declare function enableFocusInside(container: HTMLElement): void;

package/dist/utils/useLiteMergeRefs.d.ts

@@ -0,0 +1,14 @@
+import type { Ref } from '@actview/core';
+/**
+ * actview 版（upstream 为 React hook：React.useMemo 缓存回调）。
+ *
+ * 与 upstream 的差异：
+ * - ref 为 actview 框架类型 `Ref<T>`（.value，非 React 的 .current）
+ * - 支持惰性 ref（`() => Ref<T | null> | fn | undefined`）：调用时求值，
+ *   用于 portalContext 等挂载后才可用的 ref（如 FloatingFocusManager 的
+ *   merged guard refs）
+ * - actview 无 useMemo 概念——每次调用返回新闭包，需要稳定引用的调用方自行缓存
+ *   （如在 setup 中调用一次）。
+ */
+export type LiteMergeableRef<T> = Ref<T | null> | ((value: T | null) => void) | (() => Ref<T | null> | ((value: T | null) => void) | undefined);
+export declare function useLiteMergeRefs<T>(refs: Array<LiteMergeableRef<T> | undefined>): (value: T | null) => void;

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+export * from './utils/element';
+export * from './utils/nodes';
+export * from './utils/platform';
+export * from './utils/event';
+export * from './utils/hooks';
+export * from './utils/composite';
+export * from './utils/tabbable';

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@actview/floating-ui",
+  "version": "0.1.0",
+  "description": "Floating UI for ActView",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/floating-ui.actview.umd.js",
+  "module": "./dist/floating-ui.actview.esm.js",
+  "unpkg": "./dist/floating-ui.actview.umd.min.js",
+  "types": "./dist/floating-ui.actview.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/floating-ui.actview.d.mts",
+        "default": "./dist/floating-ui.actview.mjs"
+      },
+      "types": "./dist/floating-ui.actview.d.ts",
+      "module": "./dist/floating-ui.actview.esm.js",
+      "default": "./dist/floating-ui.actview.umd.js"
+    },
+    "./utils": {
+      "import": {
+        "types": "./dist/floating-ui.actview.utils.d.mts",
+        "default": "./dist/floating-ui.actview.utils.mjs"
+      },
+      "types": "./dist/floating-ui.actview.utils.d.ts",
+      "module": "./dist/floating-ui.actview.utils.esm.js",
+      "default": "./dist/floating-ui.actview.utils.umd.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "utils"
+  ],
+  "license": "MIT",
+  "bugs": "https://github.com/floating-ui/floating-ui",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/floating-ui/floating-ui.git",
+    "directory": "packages/actview"
+  },
+  "homepage": "https://floating-ui.com",
+  "keywords": [
+    "tooltip",
+    "popover",
+    "dropdown",
+    "menu",
+    "popup",
+    "positioning",
+    "actview"
+  ],
+  "dependencies": {
+    "@actview/core": "1.1.0",
+    "@actview/jsx": "1.1.0",
+    "tabbable": "^6.0.0",
+    "@floating-ui/dom": "^1.8.0",
+    "@floating-ui/utils": "^0.2.12"
+  },
+  "devDependencies": {
+    "@actview/testing": "0.1.1",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/jest-dom": "^6.2.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/node": "^20.10.6",
+    "resize-observer-polyfill": "^1.5.1",
+    "vitest": "^4.1.9",
+    "@actview/plugin-babel": "1.0.7",
+    "config": "0.0.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "format": "prettier --ignore-path ../../.gitignore --write .",
+    "clean": "rimraf dist out-tsc utils",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:browser": "vitest run --browser",
+    "build": "rollup -c && tsc -p tsconfig.lib.json && node scripts/copy-dts.mjs",
+    "typecheck": "tsc -b"
+  }
+}