ropav 0.1.6 → 0.1.8

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 {};

package/dist/components/select/useSelectNativeControl.d.ts

@@ -1,9 +0,0 @@
-import { Ref, SelectHTMLAttributes } from 'vue';
-import { SelectProps } from './types.js';
-import { SelectValue } from './useSelectNativeValue.js';
-export declare function useSelectNativeControl(props: Readonly<SelectProps>, emitUpdate: (value: SelectValue) => void, triggerRef: Readonly<Ref<HTMLElement | null>>): {
-    nativeSelectRef: Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
-    selectedValue: import('vue').ComputedRef<SelectValue>;
-    nativeInputAttrs: import('vue').ComputedRef<SelectHTMLAttributes>;
-    requestValueUpdate: (value: SelectValue) => void;
-};

package/dist/components/select/useSelectNativeValue.d.ts

@@ -1,9 +0,0 @@
-import { SelectProps } from './types.js';
-export type SelectValue = string | number | null;
-export declare function useSelectNativeValue(props: Readonly<SelectProps>, emitUpdate: (value: SelectValue) => void): {
-    nativeSelectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
-    controllable: import('../../composables/useControllableValue.js').UseControllableValueReturn<SelectValue>;
-    getNativeValue: (select: HTMLSelectElement) => string | number | null;
-    syncNativeSelection: (value: SelectValue) => void;
-    requestValueUpdate: (value: SelectValue) => void;
-};