ropav 0.0.11 → 0.0.13

package/dist/components/dropdown-menu/dropdown-menu-primitive-core.d.ts

@@ -0,0 +1,110 @@
+import { ComponentPublicInstance, ComputedRef, InjectionKey, Ref, VaporComponentInstance } from 'vue';
+import { OverlayLayerContext } from '../../composables/useOverlayLayer.js';
+import { FloatingReference } from '../floating/types.js';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuInteractOutsideEvent, DropdownMenuItemPrimitiveProps, DropdownMenuItemValue, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuPoint, DropdownMenuSelectEvent, DropdownMenuVirtualAnchor } from './types.js';
+export type ElementReference = FloatingReference;
+export type OpenFocusTarget = DropdownMenuFocusTarget | false;
+export type ComponentRefValue = Element | ComponentPublicInstance | VaporComponentInstance | null;
+export interface MenuItemRegistration {
+    id: string;
+    element: () => HTMLElement | null;
+    disabled: () => boolean;
+    activate: (event: Event) => void;
+    submenu?: DropdownMenuSubContext;
+}
+export interface DropdownMenuContext {
+    root: DropdownMenuRootContext;
+    element: Ref<HTMLElement | null>;
+    activeId: Ref<string | null>;
+    actualPlacement: Ref<DropdownMenuPlacement>;
+    parentSub?: DropdownMenuSubContext;
+    registerItem: (item: MenuItemRegistration) => void;
+    unregisterItem: (id: string) => void;
+    registerSub: (sub: DropdownMenuSubContext) => void;
+    unregisterSub: (sub: DropdownMenuSubContext) => void;
+    closeSubmenus: (except?: DropdownMenuSubContext) => void;
+    setActive: (id: string) => void;
+    isActive: (id: string) => boolean;
+    focus: (target?: DropdownMenuFocusTarget) => boolean;
+    focusElement: () => void;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface DropdownMenuSubContext {
+    isOpen: ComputedRef<boolean>;
+    trigger: Ref<HTMLElement | null>;
+    contentId: Ref<string | undefined>;
+    actualPlacement: Ref<DropdownMenuPlacement>;
+    pendingFocus: Ref<OpenFocusTarget>;
+    menu: DropdownMenuContext | null;
+    open: (focus?: OpenFocusTarget) => void;
+    close: (focusParent?: boolean) => void;
+}
+export interface DropdownMenuRootContext {
+    id: ComputedRef<string>;
+    isOpen: ComputedRef<boolean>;
+    disabled: ComputedRef<boolean>;
+    modal: ComputedRef<boolean>;
+    trigger: Ref<HTMLElement | null>;
+    triggerId: Ref<string | undefined>;
+    contentId: Ref<string | undefined>;
+    reference: ComputedRef<ElementReference | null>;
+    pendingFocus: Ref<OpenFocusTarget>;
+    layer: OverlayLayerContext;
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions & {
+        returnFocus?: boolean;
+    }) => void;
+    toggle: () => void;
+    openAt: (point: DropdownMenuPoint, options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    setTrigger: (element: HTMLElement | null, id?: string) => void;
+    setReference: (reference: ElementReference | null) => void;
+    setReturnFocus: (element: HTMLElement | null) => void;
+    registerInside: (element: HTMLElement) => void;
+    unregisterInside: (element: HTMLElement) => void;
+    isInside: (event: Event) => boolean;
+}
+export interface DropdownMenuRadioGroupContext {
+    value: ComputedRef<DropdownMenuItemValue | null>;
+    select: (value: DropdownMenuItemValue) => void;
+}
+export interface DropdownMenuCheckedContext {
+    state: ComputedRef<'checked' | 'unchecked' | 'indeterminate'>;
+    checked: ComputedRef<boolean>;
+}
+export declare const rootKey: InjectionKey<DropdownMenuRootContext>;
+export declare const menuKey: InjectionKey<DropdownMenuContext>;
+export declare const subKey: InjectionKey<DropdownMenuSubContext>;
+export declare const radioGroupKey: InjectionKey<DropdownMenuRadioGroupContext>;
+export declare const checkedKey: InjectionKey<DropdownMenuCheckedContext>;
+export declare function optionalAttr<T extends boolean | string | undefined>(value: T): T | undefined;
+export declare function getFocusTarget(options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget): DropdownMenuFocusTarget;
+export declare function toHTMLElement(value: ComponentRefValue, fallbackId?: string): HTMLElement | null;
+export declare function resolveHTMLElementRef(value: ComponentRefValue, fallbackId: string, resolve: (element: HTMLElement | null) => void): void;
+export declare function createVirtualAnchor(point: DropdownMenuPoint): DropdownMenuVirtualAnchor;
+export declare function createCustomEvent<T>(type: string, detail: T, originalEvent: Event): CustomEvent<T>;
+export declare function createSelectEvent(originalEvent: Event, value?: DropdownMenuItemValue): DropdownMenuSelectEvent;
+export declare function createOutsideEvent(originalEvent: Event): DropdownMenuInteractOutsideEvent;
+export declare function blockNextDocumentClick(): void;
+export declare function createMenuContext(options: {
+    root: DropdownMenuRootContext;
+    element: Ref<HTMLElement | null>;
+    actualPlacement: Ref<DropdownMenuPlacement>;
+    parentSub?: DropdownMenuSubContext;
+    onEscape: (event: KeyboardEvent) => void;
+}): DropdownMenuContext;
+export declare function usePrimitiveItem(componentName: string, props: Readonly<DropdownMenuItemPrimitiveProps>, emitSelect: (event: DropdownMenuSelectEvent) => void, options: {
+    checked?: ComputedRef<boolean | 'mixed'>;
+    defaultCloseOnSelect: boolean;
+    afterSelect?: () => void;
+}): {
+    menu: DropdownMenuContext;
+    id: ComputedRef<string>;
+    element: Ref<HTMLElement | null, HTMLElement | null>;
+    isDisabled: ComputedRef<boolean>;
+    focused: ComputedRef<boolean>;
+    checked: ComputedRef<boolean | "mixed"> | undefined;
+    activate: (originalEvent: Event) => void;
+    select: () => void;
+    setElement: (value: ComponentRefValue) => void;
+    onPointerenter: () => void;
+};