ropav 0.1.6 → 0.1.7

package/docs/code-architecture.md

@@ -0,0 +1,118 @@
+# Code architecture
+
+This guide defines the source structure expected from contributors. The goal is a predictable
+codebase where UI files describe rendering, behavior is testable through small interfaces, and
+shared logic has one obvious home.
+
+## Module seams
+
+A module should hide a meaningful amount of behavior behind a small interface. Extract code around
+a responsibility, not merely to reduce a line count. A useful extraction makes callers simpler and
+lets tests exercise the same interface that production code uses.
+
+Use this dependency direction:
+
+```text
+Vue components and component-local modules
+    -> internal composables
+    -> public composables
+    -> utilities
+```
+
+A higher layer may also import a lower layer directly. Lower layers must not import higher layers:
+
+- `src/utils/` does not import components or composables.
+- `src/composables/` does not import components or internal modules.
+- `src/internal/` does not import components.
+- Components may compose other components when the dependency remains acyclic.
+
+## Where code belongs
+
+| Location                                  | Responsibility                                                        |
+| ----------------------------------------- | --------------------------------------------------------------------- |
+| `src/components/<name>/*.vue`             | Template, bindings, slots, and lightweight view-derived state         |
+| `src/components/<name>/useX.ts`           | Component-specific reactive state, lifecycle, and event orchestration |
+| `src/components/<name>/<concern>Model.ts` | Pure behavior that encodes only that component's contract             |
+| `src/internal/composables/`               | Shared reactive behavior that is not part of the package interface    |
+| `src/composables/`                        | Reusable public composables exported by the package                   |
+| `src/utils/`                              | Reusable runtime helpers without component state or lifecycle         |
+| `src/utils/dom/`                          | Reusable helpers that operate on browser and DOM primitives           |
+| `tests/`, `tooling/`, `scripts/`          | Test, build, and repository automation helpers                        |
+
+Do not add catch-all `utils`, `helpers`, or `core` modules beside a component. Keep a pure helper
+local when it expresses one component's contract, and give it a semantic name such as
+`sliderModel`. Move it to `src/utils/` once more than one feature needs the behavior.
+
+## Component shape
+
+Production SFCs use `<script setup lang="ts" vapor>` and remain zero-VDOM. Do not use `h`, `VNode`,
+`defineComponent`, `createVNode`, or related VDOM block helpers in production source.
+
+Keep SFC blocks in this order:
+
+1. `<template>`
+2. `<script setup lang="ts" vapor>`
+3. `<style>`
+
+Within the script block, use this order:
+
+1. Imports
+2. `defineOptions`, props defaults, emits, and slots
+3. Composable state and template refs
+4. View-derived computed attributes
+5. Small event adapters and `defineExpose`
+
+A short computed value used only to bind the template can stay in the SFC. Move state transitions,
+timers, document listeners, multi-step event handling, and reusable calculations behind a
+composable or pure model interface.
+
+## Function design
+
+Oxlint enforces a conservative baseline of cyclomatic complexity 20, nesting depth 4, at most 5
+parameters, and at most 250 non-blank, non-comment lines per function. These are upper bounds, not
+targets.
+
+- Give each function one reason to change.
+- Prefer guard clauses over deeply nested branches.
+- Use an options object when several parameters describe one concept.
+- Split orchestration into named steps, while keeping the external interface small.
+- Accept dependencies or callbacks at the module seam instead of constructing hard-to-test global
+  dependencies inside the implementation.
+- Return observable results where practical; isolate side effects in lifecycle or event adapters.
+
+Do not create shallow pass-through functions solely to satisfy a metric. A refactor should improve
+the caller, the module interface, or the test surface.
+
+## Imports and package interfaces
+
+- Import utilities directly from their module, for example `@/utils/number`; do not add a utils
+  barrel.
+- Component `index.ts` files define package-facing exports. Internal code should not import from the
+  root package barrel.
+- Keep imports acyclic. If two modules need each other, move the shared behavior to the lowest
+  layer that owns the concept.
+- Use `import type` for type-only dependencies.
+
+## Testing
+
+Test through the interface of the extracted module:
+
+- Pure models and utilities use deterministic unit tests.
+- Composables test returned state and commands, using the smallest host needed for lifecycle
+  behavior.
+- Component tests cover DOM integration, events, accessibility, and public rendering contracts.
+- Storybook tests cover visual and interaction scenarios that depend on real browser layout.
+
+Tests should assert observable behavior rather than private implementation details. Refactoring a
+module internally should not require rewriting its behavioral tests.
+
+## Contributor checklist
+
+Before opening a pull request:
+
+- The SFC primarily adapts props, slots, and composable results to the template.
+- New reusable helpers live in `src/utils/`; feature-only pure logic has a semantic local name.
+- Dependency direction remains downward and acyclic.
+- Functions stay below the enforced complexity, depth, length, and parameter limits.
+- New behavior is tested at the module interface.
+- `pnpm run verify` passes.

package/docs/public-floating-api.md

@@ -42,7 +42,6 @@ const { actualPlacement, arrowStyle, floatingStyle } = useFloatingPosition({
   open,
   placement: 'bottom-start',
   offset: 8,
-  restartKey: () => [teleport.value, teleportTo.value],
 });
 </script>
 ```
@@ -63,7 +62,7 @@ The composable accepts plain values, refs, computed refs or getters for reactive
 | `shift`                            | `true`     | Keeps the floating element inside the collision boundary.              |
 | `collisionPadding`                 | `8`        | Padding between the floating element and viewport boundary.            |
 | `autoUpdateOptions.animationFrame` | `false`    | Tracks transform animations and detached nested floating contexts.     |
-| `restartKey`                       | —          | Rebinds auto-update observers when its reactive value changes.         |
+| `restartKey`                       | —          | Forces a rebind for reactive changes unrelated to DOM ancestry.        |
 
 Use `autoUpdateOptions.animationFrame` sparingly. It checks the reference position every animation
 frame and is intended for references moving with CSS transforms or nested floating elements outside
@@ -78,9 +77,11 @@ The return value contains readonly `actualPlacement`, `floatingStyle`, `arrowSty
 `isPositioned` refs, plus an async `update()` method for content-driven layout changes.
 
 `useTeleportTarget()` resolves the nearest `TeleportProvider` target and falls back to `body`. Pass
-a target value, ref or getter to override the provider for one floating element. Include the
-resolved target and the Teleport enabled state in `restartKey` whenever either can change while the
-floating element is open.
+a target value, ref or getter to override the provider for one floating element. Positioning
+automatically rebinds when the reference or floating element moves through the composed DOM,
+including Teleport moves, temporary detachments and slot reassignment within an existing shadow
+tree. Use `restartKey` when a reactive change outside observable DOM ancestry must recreate the
+auto-update subscriptions, such as a host attaching a new shadow root after positioning starts.
 
 Positioning does not add interaction or accessibility behavior. Custom overlays remain responsible
 for keyboard handling, focus management, roles, labels, outside interaction and dismissal.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ropav",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "license": "MIT",
   "type": "module",
   "packageManager": "pnpm@11.15.1",
@@ -192,8 +192,9 @@
   },
   "scripts": {
     "dev": "pnpm run storybook",
-    "public-api:sync": "node scripts/sync-public-api.mjs --write",
-    "public-api:check": "node scripts/sync-public-api.mjs --check",
+    "publication:sync": "node scripts/sync-package-publication.mjs --write",
+    "publication:check": "node scripts/sync-package-publication.mjs --check",
+    "publication:verify": "node scripts/verify-package-publication.mjs",
     "tokens:build": "style-dictionary build --config scripts/tokens.config.mjs --silent",
     "tokens:check": "node scripts/check-tokens.mjs",
     "typecheck": "vue-tsc -b tsconfig.app.json tsconfig.node.json tsconfig.test.json",
@@ -204,13 +205,13 @@
     "format:check": "oxfmt --check",
     "test": "vitest run --project=unit --project=tooling",
     "test:consumer-types:built": "tsc -p tests/fixtures/consumer-types/tsconfig.bundler.json && tsc -p tests/fixtures/consumer-types/tsconfig.nodenext.json",
-    "test:exports:built": "node scripts/check-exports.mjs",
+    "test:bundle:built": "node scripts/check-package-bundle.mjs",
     "test:consumer-fixture:built": "node tests/fixtures/consumer-app/check.mjs && vue-tsc -p tests/fixtures/consumer-app/tsconfig.json --noEmit && vite build --config tests/fixtures/consumer-app/vite.config.ts && node tests/fixtures/consumer-app/assertions.mjs",
-    "test:package": "pnpm run build && pnpm run test:exports:built && pnpm run test:consumer-types:built && pnpm run test:consumer-fixture:built",
+    "test:package": "pnpm run build && pnpm run publication:verify && pnpm run test:bundle:built && pnpm run test:consumer-types:built && pnpm run test:consumer-fixture:built",
     "test:watch": "vitest --project=unit --project=tooling",
     "test:typecheck": "vitest run --project=unit --project=tooling --typecheck",
     "test:storybook": "vitest run --project=storybook-light --project=storybook-dark",
-    "build": "pnpm run public-api:check && pnpm run tokens:build && pnpm run tokens:check && pnpm run typecheck && vite build",
+    "build": "pnpm run publication:check && pnpm run tokens:build && pnpm run tokens:check && pnpm run typecheck && vite build",
     "verify": "pnpm run lint && pnpm run format:check && pnpm run typecheck:storybook && pnpm run test && pnpm run test:storybook && pnpm run test:package",
     "prepublishOnly": "pnpm run verify",
     "preview": "vite preview",
@@ -220,9 +221,9 @@
     "release": "pnpm run verify && bumpp --git-check --all --commit \"chore(release): v%s\" --tag \"v%s\" --execute \"pnpm run changelog\""
   },
   "peerDependencies": {
-    "@vue/compiler-vapor": "3.6.0-rc.1",
+    "@vue/compiler-vapor": "3.6.0-rc.2",
     "unplugin-icons": "^23.0.1",
-    "vue": "^3.6.0-rc.1"
+    "vue": "^3.6.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@vue/compiler-vapor": {
@@ -245,13 +246,13 @@
     "@types/node": "^26.1.1",
     "@vitejs/plugin-vue": "^6.0.8",
     "@vitest/browser-playwright": "^4.1.10",
-    "@vue/compiler-vapor": "3.6.0-rc.1",
+    "@vue/compiler-vapor": "3.6.0-rc.2",
     "@vue/tsconfig": "^0.9.1",
-    "bumpp": "^11.1.0",
+    "bumpp": "^12.0.0",
     "conventional-changelog": "^8.1.0",
     "conventional-changelog-conventionalcommits": "^10.2.1",
     "jsdom": "^29.1.1",
-    "oxfmt": "^0.59.0",
+    "oxfmt": "^0.60.0",
     "oxlint": "^1.75.0",
     "playwright": "^1.61.1",
     "sass-embedded": "^1.100.0",
@@ -263,7 +264,7 @@
     "vite": "^8.1.5",
     "vite-plugin-dts": "^5.0.3",
     "vitest": "^4.1.10",
-    "vue": "3.6.0-rc.1",
+    "vue": "3.6.0-rc.2",
     "vue-tsc": "^3.3.7"
   },
   "repository": {

package/dist/components/dropdown-menu/dropdown-menu-outside.d.ts

@@ -1,3 +0,0 @@
-import { DropdownMenuInteractOutsideTarget } from './types.js';
-export declare function isEventWithinElement(event: Event, element: Element): boolean;
-export declare function isEventWithinTargets(event: Event, targets: readonly DropdownMenuInteractOutsideTarget[]): boolean;

package/dist/components/dropdown-menu/dropdown-menu-utils.d.ts

@@ -1,21 +0,0 @@
-import { DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuOpenOptions, DropdownMenuPlacement } from './types.js';
-export declare const DEFAULT_PLACEMENT: DropdownMenuPlacement;
-export declare const DEFAULT_FOCUS_TARGET: DropdownMenuFocusTarget;
-export type ItemPath = DropdownMenuItemPath;
-export type SubmenuFocusTarget = DropdownMenuFocusTarget | false;
-export type PointerPoint = {
-    x: number;
-    y: number;
-};
-export declare function getOpenFocusTarget(options: DropdownMenuOpenOptions | DropdownMenuFocusTarget | undefined): DropdownMenuFocusTarget;
-export declare function getItemClass(item: DropdownMenuItem, focused: boolean, disabled: boolean, hasSubmenu: boolean, submenuOpen: boolean): string[];
-export declare function hasItemSubmenu(item: DropdownMenuItem): boolean;
-export declare function hasNestedItems(items: DropdownMenuItem[]): boolean;
-export declare function getPathKey(path: ItemPath): string;
-export declare function getParentPath(path: ItemPath): number[];
-export declare function arePathsEqual(a: ItemPath, b: ItemPath): boolean;
-export declare function isPathPrefix(prefix: ItemPath, path: ItemPath): boolean;
-export declare function normalizePath(indexOrPath: number | ItemPath): ItemPath;
-export declare function getEventPoint(event: MouseEvent): PointerPoint;
-export declare function hasMeasuredRect(rect: DOMRect): boolean;
-export declare function isPointInRect(point: PointerPoint, rect: DOMRect, padding?: number): boolean;

package/dist/components/dropdown-menu/useDropdownMenuDisclosure.d.ts

@@ -1,36 +0,0 @@
-import { Ref } from 'vue';
-import { OverlayLayerContext } from '../../internal/composables/useOverlayLayer.js';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuInteractOutsideEvent, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
-import { ItemPath } from './dropdown-menu-utils.js';
-type BooleanSource = Readonly<Ref<boolean>>;
-type UseDropdownMenuDisclosureOptions = {
-    props: Readonly<DropdownMenuProps>;
-    emit: {
-        select?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
-        pointerDownOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
-        focusOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
-        interactOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
-    };
-    rootRef: Ref<HTMLElement | null>;
-    menuRef: Ref<HTMLElement | null>;
-    targetRef: Readonly<Ref<Element | null>>;
-    setControllableOpen: (open: boolean) => void;
-    isDisabled: BooleanSource;
-    isOpen: BooleanSource;
-    isVisible: BooleanSource;
-    focusedPath: Ref<ItemPath>;
-    resetFocus: () => void;
-    resetSubmenus: () => void;
-    resetHoverIntent: () => void;
-    focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
-    focusMenu: () => void;
-    focusTrigger: () => void;
-    layer: OverlayLayerContext;
-};
-export declare function useDropdownMenuDisclosure({ props, emit, rootRef, menuRef, targetRef, setControllableOpen, isDisabled, isOpen, isVisible, focusedPath, resetFocus, resetSubmenus, resetHoverIntent, focusItem, focusMenu, focusTrigger, layer, }: UseDropdownMenuDisclosureOptions): {
-    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
-    close: (options?: DropdownMenuCloseOptions) => void;
-    toggle: () => void;
-    resetMenuFocus: () => void;
-};
-export {};

package/dist/components/dropdown-menu/useDropdownMenuDom.d.ts

@@ -1,29 +0,0 @@
-import { Ref } from 'vue';
-import { DropdownMenuPlacement } from './types.js';
-import { ItemPath } from './dropdown-menu-utils.js';
-type StringSource = {
-    readonly value: string;
-};
-type PlacementSource = {
-    readonly value: DropdownMenuPlacement;
-};
-type UseDropdownMenuDomOptions = {
-    menuId: StringSource;
-    rootRef: Ref<HTMLElement | null>;
-    menuRef: Ref<HTMLElement | null>;
-    targetRef: Readonly<Ref<Element | null>>;
-    placement: PlacementSource;
-    focusedPath: Ref<ItemPath>;
-};
-export declare function useDropdownMenuDom({ menuId, rootRef, menuRef, targetRef, placement, focusedPath, }: UseDropdownMenuDomOptions): {
-    activeDescendantId: import('vue').ComputedRef<string | undefined>;
-    focusMenu: () => void;
-    focusTrigger: () => void;
-    getItemId: (indexOrPath: number | ItemPath) => string;
-    getSubmenuId: (path: ItemPath) => string;
-    getItemElement: (path: ItemPath) => HTMLElement | null;
-    getSubmenuElement: (path: ItemPath) => HTMLElement | null;
-    isSubmenuOpeningLeft: (path: ItemPath) => boolean;
-    getMenuActiveDescendant: (menuPath: ItemPath) => string | undefined;
-};
-export {};

package/dist/components/dropdown-menu/useDropdownMenuInteractions.d.ts

@@ -1,52 +0,0 @@
-import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
-import { ItemPath, PointerPoint, SubmenuFocusTarget } from './dropdown-menu-utils.js';
-type BooleanSource = Readonly<Ref<boolean>>;
-type DisclosureControls = {
-    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
-    close: (options?: DropdownMenuCloseOptions) => void;
-    toggle: () => void;
-};
-type SubmenuControls = {
-    closeSubmenusAfter: (menuPath: ItemPath) => void;
-    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget) => boolean;
-    closeSubmenu: (path: ItemPath) => boolean;
-    closeCurrentSubmenu: () => boolean;
-};
-type HoverIntentControls = {
-    clearPendingHover: () => void;
-    resetHoverIntent: () => void;
-    trackSubmenuOpen: (path: ItemPath, point?: PointerPoint) => void;
-    handleItemHover: (item: DropdownMenuItem, path: ItemPath, event: MouseEvent | undefined, commit: (item: DropdownMenuItem, path: ItemPath, point?: PointerPoint) => void) => void;
-    handleMenuMousemove: (event: MouseEvent, commit: (item: DropdownMenuItem, path: ItemPath, point?: PointerPoint) => void) => void;
-};
-type UseDropdownMenuInteractionsOptions = {
-    props: Readonly<DropdownMenuProps>;
-    emit: {
-        select?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
-    };
-    isDisabled: BooleanSource;
-    focusedPath: Ref<ItemPath>;
-    openSubmenuPath: Ref<ItemPath>;
-    getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
-    focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
-    moveFocus: (direction: 1 | -1) => ItemPath | undefined;
-    handleTypeahead: (event: KeyboardEvent) => boolean;
-    submenus: SubmenuControls;
-    hoverIntent: HoverIntentControls;
-    disclosure: DisclosureControls;
-    isSubmenuOpeningLeft: (path: ItemPath) => boolean;
-};
-export declare function useDropdownMenuInteractions({ props, emit, isDisabled, focusedPath, openSubmenuPath, getItemAtPath, focusItem, moveFocus, handleTypeahead, submenus, hoverIntent, disclosure, isSubmenuOpeningLeft, }: UseDropdownMenuInteractionsOptions): {
-    activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent | KeyboardEvent) => void;
-    selectItem: (item: DropdownMenuItem, originalEvent?: Event) => void;
-    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget, point?: PointerPoint) => boolean;
-    closeSubmenu: (path: ItemPath) => boolean;
-    focusHoveredItem: (item: DropdownMenuItem, indexOrPath: number | ItemPath, event?: MouseEvent) => void;
-    onTriggerClick: () => void;
-    onTriggerKeydown: (event: KeyboardEvent) => void;
-    onMenuKeydown: (event: KeyboardEvent) => void;
-    onMenuMousemove: (event: MouseEvent) => void;
-    onMenuMouseleave: () => void;
-};
-export {};

package/dist/components/dropdown-menu/useDropdownMenuNavigation.d.ts

@@ -1,17 +0,0 @@
-import { DropdownMenuFocusTarget, DropdownMenuItem } from './types.js';
-import { ItemPath } from './dropdown-menu-utils.js';
-type DropdownMenuItemsSource = {
-    readonly value: DropdownMenuItem[];
-};
-export declare function useDropdownMenuNavigation(items: DropdownMenuItemsSource): {
-    focusedPath: import('vue').Ref<number[], number[] | import('./types.js').DropdownMenuItemPath>;
-    focusedIndex: import('vue').ComputedRef<number>;
-    getItemsAtPath: (path: ItemPath) => DropdownMenuItem[];
-    getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
-    focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
-    resetFocus: () => void;
-    setFocusedIndex: (index: number, menuPath?: ItemPath) => boolean;
-    isItemFocused: (indexOrPath: number | ItemPath) => boolean;
-    moveFocus: (direction: 1 | -1) => number[] | undefined;
-};
-export {};

package/dist/components/dropdown-menu/useDropdownSubmenus.d.ts

@@ -1,18 +0,0 @@
-import { Ref } from 'vue';
-import { DropdownMenuItem } from './types.js';
-import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-utils.js';
-type UseDropdownSubmenusOptions = {
-    focusedPath: Ref<ItemPath>;
-    getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
-    focusItem: (target: Exclude<SubmenuFocusTarget, false>, menuPath?: ItemPath) => boolean;
-};
-export declare function useDropdownSubmenus({ focusedPath, getItemAtPath, focusItem, }: UseDropdownSubmenusOptions): {
-    openSubmenuPath: Ref<number[], number[] | import('./types.js').DropdownMenuItemPath>;
-    resetSubmenus: () => void;
-    isSubmenuOpen: (path: ItemPath) => boolean;
-    closeSubmenusAfter: (menuPath: ItemPath) => void;
-    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget) => boolean;
-    closeSubmenu: (path: ItemPath) => boolean;
-    closeCurrentSubmenu: () => boolean;
-};
-export {};

package/dist/components/scroll-area/scrollAreaCore.d.ts

@@ -1,30 +0,0 @@
-import { ScrollAreaScrollbars, ScrollAreaType } from './types.js';
-export type ScrollAxis = 'x' | 'y';
-export type ScrollDirection = 'ltr' | 'rtl';
-export interface ScrollAreaMetrics {
-    direction: ScrollDirection;
-    clientWidth: number;
-    clientHeight: number;
-    scrollWidth: number;
-    scrollHeight: number;
-    x: number;
-    y: number;
-    overflowX: boolean;
-    overflowY: boolean;
-    horizontalThumbSize: number;
-    horizontalThumbOffset: number;
-    verticalThumbSize: number;
-    verticalThumbOffset: number;
-}
-export declare function clamp(value: number, min: number, max: number): number;
-export declare function getScrollDirection(viewport: HTMLElement): ScrollDirection;
-export declare function getLogicalHorizontalPosition(scrollLeft: number, maxPosition: number, direction: ScrollDirection): number;
-export declare function getRawHorizontalPosition(position: number, maxPosition: number, direction: ScrollDirection): number;
-export declare function isAxisEnabled(scrollbars: ScrollAreaScrollbars | false | undefined, axis: ScrollAxis): boolean;
-export declare function isScrollbarActive(type: ScrollAreaType, enabled: boolean, overflowing: boolean): boolean;
-export declare function getThumbGeometry(trackSize: number, viewportSize: number, scrollSize: number): {
-    size: number;
-    offsetRatio: number;
-};
-export declare function getThumbOffset(position: number, maxPosition: number, sizeRatio: number): number;
-export declare function getLengthValue(value: number | string | undefined): string;

package/dist/components/scroll-area/useScrollAreaControls.d.ts

@@ -1,25 +0,0 @@
-import { Ref } from 'vue';
-import { ScrollAxis } from './scrollAreaCore.js';
-import { ScrollAreaMetricsController } from './useScrollAreaMetrics.js';
-import { ScrollAreaPosition } from './types.js';
-interface UseScrollAreaControlsOptions {
-    viewportRef: Ref<HTMLElement | null>;
-    metrics: ScrollAreaMetricsController;
-    showDuringScroll: () => void;
-    emitScroll: (event: Event) => void;
-    emitPositionChange: (position: ScrollAreaPosition) => void;
-    emitReachTop: (event: Event) => void;
-    emitReachBottom: (event: Event) => void;
-    emitReachLeft: (event: Event) => void;
-    emitReachRight: (event: Event) => void;
-}
-export declare function useScrollAreaControls(options: UseScrollAreaControlsOptions): {
-    onViewportScroll: (event: Event) => void;
-    onScrollbarKeydown: (axis: ScrollAxis, event: KeyboardEvent) => void;
-    onScrollbarWheel: (axis: ScrollAxis, event: WheelEvent) => void;
-    writeAxisPosition: (axis: ScrollAxis, value: number) => void;
-    scrollTo: (scrollOptions: ScrollToOptions) => void;
-    scrollBy: (scrollOptions: ScrollToOptions) => void;
-};
-export type ScrollAreaControlsController = ReturnType<typeof useScrollAreaControls>;
-export {};

package/dist/components/scroll-area/useScrollAreaMetrics.d.ts

@@ -1,38 +0,0 @@
-import { Ref } from 'vue';
-import { ScrollAxis } from './scrollAreaCore.js';
-import { ScrollAreaPosition } from './types.js';
-interface UseScrollAreaMetricsOptions {
-    viewportRef: Ref<HTMLElement | null>;
-    contentRef: Ref<HTMLElement | null>;
-    horizontalScrollbarRef: Ref<HTMLElement | null>;
-    verticalScrollbarRef: Ref<HTMLElement | null>;
-    horizontalEnabled: Readonly<Ref<boolean>>;
-    verticalEnabled: Readonly<Ref<boolean>>;
-}
-export declare function useScrollAreaMetrics(options: UseScrollAreaMetricsOptions): {
-    metrics: {
-        direction: import('./scrollAreaCore.js').ScrollDirection;
-        clientWidth: number;
-        clientHeight: number;
-        scrollWidth: number;
-        scrollHeight: number;
-        x: number;
-        y: number;
-        overflowX: boolean;
-        overflowY: boolean;
-        horizontalThumbSize: number;
-        horizontalThumbOffset: number;
-        verticalThumbSize: number;
-        verticalThumbOffset: number;
-    };
-    position: import('vue').ComputedRef<ScrollAreaPosition>;
-    update: () => void;
-    updatePosition: (viewport?: HTMLElement | null) => void;
-    scheduleUpdate: () => void;
-    schedulePositionUpdate: () => void;
-    getPosition: (axis: ScrollAxis) => number;
-    getMaxPosition: (axis: ScrollAxis) => number;
-    getOverflow: (axis: ScrollAxis) => boolean;
-};
-export type ScrollAreaMetricsController = ReturnType<typeof useScrollAreaMetrics>;
-export {};