hys-ui 0.5.0 → 0.7.0

package/dist/types/composables/table.d.ts

@@ -181,11 +181,12 @@ export interface HysTablePagination {
     hideOnSinglePage?: boolean;
 }
 export interface HysTableQuery<T extends object = Record<string, unknown>> {
-    action: "sort" | "filter" | "page" | "pageSize";
+    action: "sort" | "filter" | "page" | "pageSize" | "search";
     page: number;
     pageSize: number;
     sorts: HysTableSort[];
     filters: HysTableFilters;
+    search?: string;
     currentData: T[];
 }
 export interface HysTableLoadContext {
@@ -290,6 +291,7 @@ export interface HysTableProps<T extends object> {
     selectionColumn?: HysTableSelectionColumn;
     getSelectionProps?: (row: T, index: number) => HysTableSelectionProps;
     highlightCurrentRow?: boolean;
+    keyboardNavigation?: boolean;
     currentRowKey?: HysTableKey | null;
     defaultCurrentRowKey?: HysTableKey;
     showIndex?: boolean;
@@ -303,6 +305,10 @@ export interface HysTableProps<T extends object> {
     showSorterTooltip?: boolean | HysTableOverflowTooltipOptions;
     filters?: HysTableFilters;
     defaultFilters?: HysTableFilters;
+    search?: string;
+    defaultSearch?: string;
+    searchColumns?: readonly string[];
+    searchMethod?: (search: string, row: T) => boolean;
     filterColumnKey?: string | null;
     filterPlacement?: Placement;
     appendFilterTo?: string | HTMLElement | false;
@@ -376,6 +382,9 @@ export interface HysTableInstance<T extends object = Record<string, unknown>> {
     setSort: (sort: HysTableSort | readonly HysTableSort[] | null) => void;
     clearFilter: (keys?: readonly string[]) => void;
     setFilter: (key: string, values: readonly HysTableFilterValue[]) => void;
+    setSearch: (search: string) => void;
+    clearSearch: () => void;
+    focusRow: (row: T | HysTableKey) => boolean;
     showFilter: (key: string) => Promise<boolean>;
     hideFilter: () => Promise<boolean>;
     setPage: (page: number) => void;

package/dist/types/composables/toastEscape.d.ts

@@ -1 +1 @@
-export declare function registerToastEscape(close: () => void): () => void;
+export declare function registerToastEscape(close: (event: KeyboardEvent) => void, element: () => HTMLElement | undefined): (() => void) | undefined;

package/dist/types/composables/toastQueue.d.ts

@@ -0,0 +1,121 @@
+import type { HysToastApi, HysToastCloseContext, HysToastConfig, HysToastType } from "../components/HysToast/toastTypes";
+import { type ToastEntry, type ToastInstance } from "./toastQueueModel";
+export declare function createToastQueue(config: HysToastConfig, host: {
+    mount: () => void;
+    empty: () => void;
+}, reportError: (error: unknown) => void): {
+    api: HysToastApi;
+    records: import("vue").ShallowReactive<Map<string, ToastEntry>>;
+    settings: import("vue").ShallowRef<{
+        maxCount?: number;
+        maxQueue?: number;
+        overflow?: "replace" | "queue";
+        queueOrder?: "fifo" | "lifo";
+        queueScope?: "global" | "position" | "type" | "group";
+        layout?: "vertical" | "horizontal" | "layered";
+        gap?: number;
+        collapsedCount?: number;
+        layerCount?: number;
+        layerTrigger?: "hover" | "click" | "both";
+        grouping?: boolean;
+        dedupe?: "ignore" | "merge";
+        dedupeWindow?: number;
+        appendTo?: string | HTMLElement | ShadowRoot;
+        progress?: import("./useHysToast").HysToastProgress | undefined;
+        type?: HysToastType | undefined;
+        width?: string | number | undefined;
+        direction?: import("./useHysToast").HysToastDirection | undefined;
+        offset?: number | undefined;
+        duration?: number | undefined;
+        animation?: (import("./useHysToast").HysToastAnimation | import("./useHysToast").HysToastMotionPreset) | undefined;
+        closable?: boolean | undefined;
+        showIcon?: boolean | undefined;
+        beforeClose?: ((context: HysToastCloseContext) => boolean | void | Promise<boolean | void>) | undefined;
+        easing?: string | ((progress: number) => number) | undefined;
+        plain?: boolean | undefined;
+        locale?: Partial<import("./useHysToast").HysToastLocale> | undefined;
+        position?: import("./useHysToast").HysToastPosition | undefined;
+        animationDuration?: number | undefined;
+        zIndex?: number | undefined;
+        maxLines?: number | undefined;
+        actions?: readonly import("./useHysToast").HysToastAction[] | undefined;
+        closeOnEscape?: boolean | undefined;
+        live?: "polite" | "assertive" | "off" | undefined;
+        coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
+        glass?: boolean | undefined;
+        swipe?: boolean | undefined;
+        persistent?: boolean | undefined;
+        closeOnClick?: boolean | undefined;
+        keyboardDismiss?: boolean | undefined;
+        pauseOnHover?: boolean | undefined;
+        pauseOnBlur?: boolean | undefined;
+        interactive?: boolean | undefined;
+        offsetX?: number | undefined;
+        offsetY?: number | undefined;
+        toastStyle?: import("vue").CSSProperties | undefined;
+        progressStyle?: import("vue").CSSProperties | undefined;
+        showProgress?: boolean | undefined;
+        countdown?: boolean | undefined;
+        copyable?: boolean | undefined;
+        actionLayout?: "inline" | "footer" | undefined;
+    }, {
+        maxCount?: number;
+        maxQueue?: number;
+        overflow?: "replace" | "queue";
+        queueOrder?: "fifo" | "lifo";
+        queueScope?: "global" | "position" | "type" | "group";
+        layout?: "vertical" | "horizontal" | "layered";
+        gap?: number;
+        collapsedCount?: number;
+        layerCount?: number;
+        layerTrigger?: "hover" | "click" | "both";
+        grouping?: boolean;
+        dedupe?: "ignore" | "merge";
+        dedupeWindow?: number;
+        appendTo?: string | HTMLElement | ShadowRoot;
+        progress?: import("./useHysToast").HysToastProgress | undefined;
+        type?: HysToastType | undefined;
+        width?: string | number | undefined;
+        direction?: import("./useHysToast").HysToastDirection | undefined;
+        offset?: number | undefined;
+        duration?: number | undefined;
+        animation?: (import("./useHysToast").HysToastAnimation | import("./useHysToast").HysToastMotionPreset) | undefined;
+        closable?: boolean | undefined;
+        showIcon?: boolean | undefined;
+        beforeClose?: ((context: HysToastCloseContext) => boolean | void | Promise<boolean | void>) | undefined;
+        easing?: string | ((progress: number) => number) | undefined;
+        plain?: boolean | undefined;
+        locale?: Partial<import("./useHysToast").HysToastLocale> | undefined;
+        position?: import("./useHysToast").HysToastPosition | undefined;
+        animationDuration?: number | undefined;
+        zIndex?: number | undefined;
+        maxLines?: number | undefined;
+        actions?: readonly import("./useHysToast").HysToastAction[] | undefined;
+        closeOnEscape?: boolean | undefined;
+        live?: "polite" | "assertive" | "off" | undefined;
+        coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
+        glass?: boolean | undefined;
+        swipe?: boolean | undefined;
+        persistent?: boolean | undefined;
+        closeOnClick?: boolean | undefined;
+        keyboardDismiss?: boolean | undefined;
+        pauseOnHover?: boolean | undefined;
+        pauseOnBlur?: boolean | undefined;
+        interactive?: boolean | undefined;
+        offsetX?: number | undefined;
+        offsetY?: number | undefined;
+        toastStyle?: import("vue").CSSProperties | undefined;
+        progressStyle?: import("vue").CSSProperties | undefined;
+        showProgress?: boolean | undefined;
+        countdown?: boolean | undefined;
+        copyable?: boolean | undefined;
+        actionLayout?: "inline" | "footer" | undefined;
+    }>;
+    order: (a: ToastEntry, b: ToastEntry) => number;
+    notify: <T extends unknown[]>(callback: ((...args: T) => void) | undefined, ...args: T) => void;
+    begin: (entry: ToastEntry, closeContext: HysToastCloseContext) => void;
+    finish: (entry: ToastEntry) => void;
+    setInstance: (entry: ToastEntry, instance: ToastInstance | null, stack: string) => void;
+    suspend: (permanent?: boolean) => void;
+    resume: () => void;
+};

package/dist/types/composables/toastQueueModel.d.ts

@@ -0,0 +1,116 @@
+import type { ToastClock } from "../components/HysToast/useToastTimer";
+import type { HysToastCloseContext, HysToastCloseReason, HysToastConfig, HysToastContext, HysToastFilter, HysToastHandle, HysToastOptions, HysToastSnapshot, HysToastStatus } from "../components/HysToast/toastTypes";
+export interface ToastInstance {
+    close(reason?: HysToastCloseReason, event?: Event, force?: boolean): Promise<boolean>;
+    restart(): void;
+    extend(milliseconds: number): void;
+    snapshotClock(): ToastClock;
+    restoreClock(clock: ToastClock): void;
+}
+export interface ToastEntry {
+    id: string;
+    serial: number;
+    options: HysToastOptions;
+    status: HysToastStatus;
+    repeat: number;
+    lastSeen: number;
+    paused: boolean;
+    extending: number;
+    clock?: ToastClock;
+    shown?: boolean;
+    entered?: boolean;
+    closeContext?: HysToastCloseContext;
+    handle: HysToastHandle;
+    resolve: () => void;
+}
+export declare const nextToastSequence: () => number;
+export declare const asOptions: (value: string | HysToastOptions) => HysToastOptions;
+export declare function presentation(options: HysToastOptions): {
+    message?: string;
+    title?: string;
+    type?: import("./useHysToast").HysToastType;
+    duration?: number;
+    persistent?: boolean;
+    closable?: boolean;
+    closeOnClick?: boolean;
+    closeOnEscape?: boolean;
+    keyboardDismiss?: boolean;
+    pauseOnHover?: boolean;
+    pauseOnBlur?: boolean;
+    swipe?: boolean;
+    interactive?: boolean;
+    position?: import("./useHysToast").HysToastPosition;
+    offset?: number;
+    offsetX?: number;
+    offsetY?: number;
+    coordinates?: import("./useHysToast").HysToastCoordinates;
+    zIndex?: number;
+    width?: string | number;
+    showIcon?: boolean;
+    plain?: boolean;
+    glass?: boolean;
+    theme?: import("..").HysTheme;
+    toastStyle?: import("vue").CSSProperties;
+    progressStyle?: import("vue").CSSProperties;
+    progress?: import("./useHysToast").HysToastProgress;
+    showProgress?: boolean;
+    countdown?: boolean;
+    maxLines?: number;
+    copyable?: boolean;
+    copyText?: string;
+    actionLayout?: "inline" | "footer";
+    actions?: readonly import("./useHysToast").HysToastAction[];
+    animation?: import("./useHysToast").HysToastAnimation | import("./useHysToast").HysToastMotionPreset;
+    direction?: import("./useHysToast").HysToastDirection;
+    animationDuration?: number;
+    easing?: string | ((progress: number) => number);
+    live?: "polite" | "assertive" | "off";
+    locale?: Partial<import("./useHysToast").HysToastLocale>;
+    beforeClose?: (context: HysToastCloseContext) => boolean | void | Promise<boolean | void>;
+};
+export declare function toastStackKey(options: HysToastOptions): string;
+export declare function defaults(config: HysToastConfig): {
+    grouping?: boolean;
+    dedupe?: "ignore" | "merge";
+    dedupeWindow?: number;
+    progress?: import("./useHysToast").HysToastProgress | undefined;
+    type?: import("./useHysToast").HysToastType | undefined;
+    width?: string | number | undefined;
+    direction?: import("./useHysToast").HysToastDirection | undefined;
+    offset?: number | undefined;
+    duration?: number | undefined;
+    animation?: (import("./useHysToast").HysToastAnimation | import("./useHysToast").HysToastMotionPreset) | undefined;
+    closable?: boolean | undefined;
+    showIcon?: boolean | undefined;
+    beforeClose?: ((context: HysToastCloseContext) => boolean | void | Promise<boolean | void>) | undefined;
+    easing?: string | ((progress: number) => number) | undefined;
+    plain?: boolean | undefined;
+    locale?: Partial<import("./useHysToast").HysToastLocale> | undefined;
+    position?: import("./useHysToast").HysToastPosition | undefined;
+    animationDuration?: number | undefined;
+    zIndex?: number | undefined;
+    maxLines?: number | undefined;
+    actions?: readonly import("./useHysToast").HysToastAction[] | undefined;
+    closeOnEscape?: boolean | undefined;
+    live?: "polite" | "assertive" | "off" | undefined;
+    coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
+    glass?: boolean | undefined;
+    swipe?: boolean | undefined;
+    persistent?: boolean | undefined;
+    closeOnClick?: boolean | undefined;
+    keyboardDismiss?: boolean | undefined;
+    pauseOnHover?: boolean | undefined;
+    pauseOnBlur?: boolean | undefined;
+    interactive?: boolean | undefined;
+    offsetX?: number | undefined;
+    offsetY?: number | undefined;
+    toastStyle?: import("vue").CSSProperties | undefined;
+    progressStyle?: import("vue").CSSProperties | undefined;
+    showProgress?: boolean | undefined;
+    countdown?: boolean | undefined;
+    copyable?: boolean | undefined;
+    actionLayout?: "inline" | "footer" | undefined;
+};
+export declare function context(entry: ToastEntry): HysToastContext;
+export declare function snapshot(entry: ToastEntry): HysToastSnapshot;
+export declare function matches(entry: ToastEntry, filter?: HysToastFilter): boolean;

package/dist/types/composables/toastTasks.d.ts

@@ -0,0 +1,2 @@
+import type { HysToastApi } from "../components/HysToast/toastTypes";
+export declare function createToastTaskRunner(show: HysToastApi["show"], reportError: (error: unknown) => void): HysToastApi["promise"];

package/dist/types/composables/useColorPicker.d.ts

@@ -44,7 +44,7 @@ export declare function useColorPicker(props: HysColorPickerProps, emit: (name:
         placement: import("vue").Ref<import("./useFloating").Placement, import("./useFloating").Placement>;
         update: () => void;
         show: (force?: boolean) => Promise<void>;
-        close: (restore?: boolean, force?: boolean) => void;
+        close: (restore?: boolean, force?: boolean, source?: "outside" | "escape" | "anchor") => void;
         toggle: () => void | Promise<void>;
         restoringFocus: import("vue").Ref<boolean, boolean>;
         schedule: () => void;

package/dist/types/composables/useContainerWidth.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from "vue";
+export declare function useContainerWidth(element: Ref<HTMLElement | undefined>): import("vue").ComputedRef<number>;

package/dist/types/composables/useContextMenu.d.ts

@@ -44,7 +44,7 @@ export declare function useContextMenu<N extends object>(props: HysContextMenuPr
         placement: Ref<import("./useFloating").Placement, import("./useFloating").Placement>;
         update: () => void;
         show: (force?: boolean) => Promise<void>;
-        close: (restore?: boolean, force?: boolean) => void;
+        close: (restore?: boolean, force?: boolean, source?: "outside" | "escape" | "anchor") => void;
         toggle: () => void | Promise<void>;
         restoringFocus: Ref<boolean, boolean>;
         schedule: () => void;

package/dist/types/composables/useFloating.d.ts

@@ -21,7 +21,7 @@ export declare function useFloating(anchor: Readonly<Ref<FloatingAnchor | undefi
     matchWidth?: boolean | "min" | (() => boolean | "min");
     width?: () => number | string | undefined;
     maxWidth?: () => number | string | undefined;
-    requestOpen?: (open: boolean, restoreFocus?: boolean) => boolean | void;
+    requestOpen?: (open: boolean, restoreFocus?: boolean, source?: "outside" | "escape" | "anchor") => boolean | void;
     closeOnTab?: boolean;
     closeOnEscape?: boolean;
     closeOnOutside?: boolean;
@@ -37,7 +37,7 @@ export declare function useFloating(anchor: Readonly<Ref<FloatingAnchor | undefi
     placement: Ref<Placement, Placement>;
     update: () => void;
     show: (force?: boolean) => Promise<void>;
-    close: (restore?: boolean, force?: boolean) => void;
+    close: (restore?: boolean, force?: boolean, source?: "outside" | "escape" | "anchor") => void;
     toggle: () => void | Promise<void>;
     restoringFocus: Ref<boolean, boolean>;
     schedule: () => void;

package/dist/types/composables/useHysToast.d.ts

@@ -1,50 +1,6 @@
-import { type VNodeChild } from 'vue';
-import type { HysToastPosition, HysToastType } from '../components/HysToast/HysToast.vue';
-import { type HysConfig } from '../config';
-export interface HysToastOptions {
-    id?: string;
-    message?: string;
-    content?: VNodeChild | (() => VNodeChild);
-    type?: HysToastType;
-    duration?: number;
-    closable?: boolean;
-    position?: HysToastPosition;
-    offset?: number;
-    zIndex?: number;
-    showIcon?: boolean;
-    icon?: VNodeChild | (() => VNodeChild);
-    plain?: boolean;
-    pauseOnHover?: boolean;
-    closeOnEscape?: boolean;
-    grouping?: boolean;
-    onClose?: () => void;
-    onAfterClose?: () => void;
-}
-export interface HysToastConfig extends Omit<HysToastOptions, 'id' | 'message' | 'content' | 'icon' | 'onClose' | 'onAfterClose'> {
-    maxCount?: number;
-    appendTo?: string | HTMLElement | ShadowRoot;
-}
-export interface HysToastHandle {
-    readonly id: string;
-    readonly closed: Promise<void>;
-    close(): void;
-    update(value: string | Omit<Partial<HysToastOptions>, 'id'>): void;
-}
-export interface HysToastApi {
-    show(value: string | HysToastOptions): HysToastHandle;
-    success(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    info(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    warning(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    error(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    loading(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    closeAll(): void;
-}
-export interface HysToastServiceConfig extends HysToastConfig, HysConfig {
-}
-export interface HysToastService extends HysToastApi {
-    dispose(): void;
-}
-/** Call during setup. Messages inherit the owner's theme and are removed when its scope leaves. */
+import type { HysToastApi, HysToastConfig, HysToastService, HysToastServiceConfig } from "../components/HysToast/toastTypes";
+export type * from "../components/HysToast/toastTypes";
 export declare function useHysToast(config?: HysToastConfig): HysToastApi;
-/** Create a shared service for callers outside setup; dispose it when the owning application ends. */
 export declare function createHysToast(config?: HysToastServiceConfig): HysToastService;
+export declare function configureHysToast(config: HysToastServiceConfig): void;
+export declare const hysToast: HysToastService;

package/dist/types/composables/usePageVisibility.d.ts

@@ -0,0 +1 @@
+export declare function usePageVisibility(): Readonly<import("vue").Ref<boolean, boolean>>;

package/dist/types/composables/usePopupSurface.d.ts

@@ -1,6 +1,32 @@
 import { type CSSProperties, type HTMLAttributes } from "vue";
 import type { HysPopupSurfaceContext, HysPopupSurfaceProps } from "./popupSurface";
-export declare function usePopupSurface(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", emit: (name: string, ...args: any[]) => void): {
+import { type PopupCloseSource } from "./usePopupSurfaceInteractions";
+export declare function usePopupSurface(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", emit: (name: string, ...args: any[]) => void, hooks?: {
+    allowClose?: (source: PopupCloseSource) => boolean;
+    onDismiss?: (source: PopupCloseSource) => void;
+    allowTabExit?: boolean;
+    shouldRestoreFocus?: () => boolean;
+}): {
+    afterEnter: () => Promise<void>;
+    afterLeave: () => Promise<void>;
+    inactive: () => void;
+    request: (value: boolean, restore?: boolean, source?: PopupCloseSource, notifyDismiss?: boolean) => Promise<boolean>;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    updatePosition: () => void;
+    focus: () => void | undefined;
+    pointerEnter: () => void;
+    pointerLeave: () => void;
+    panelEnter: () => void;
+    panelLeave: () => void;
+    focusIn: (event: FocusEvent) => void;
+    focusOut: (event: FocusEvent) => void;
+    panelFocusIn: () => void;
+    panelFocusOut: (event: FocusEvent) => void;
+    click: (event: MouseEvent) => void;
+    contextmenu: (event: MouseEvent) => void;
+    key: (event: KeyboardEvent) => void;
     wrapper: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
     referenceElement: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
     panel: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
@@ -12,7 +38,7 @@ export declare function usePopupSurface(props: HysPopupSurfaceProps, kind: "tool
     placement: import("vue").Ref<import("./useFloating").Placement, import("./useFloating").Placement>;
     active: import("vue").ComputedRef<boolean>;
     mounted: import("vue").ComputedRef<boolean>;
-    teleportTo: import("vue").ComputedRef<Element>;
+    teleportTo: import("vue").ComputedRef<string | Element>;
     arrowStyle: import("vue").Ref<{
         [x: `--${string}`]: string | number | undefined;
         accentColor?: import("csstype").Property.AccentColor | undefined;
@@ -3318,24 +3344,4 @@ export declare function usePopupSurface(props: HysPopupSurfaceProps, kind: "tool
     contentStyle: import("vue").ComputedRef<CSSProperties>;
     scope: import("vue").ComputedRef<HysPopupSurfaceContext>;
     wrapperAttrs: import("vue").ComputedRef<HTMLAttributes>;
-    pointerEnter: () => void;
-    pointerLeave: () => void;
-    panelEnter: () => void;
-    panelLeave: () => void;
-    focusIn: (event: FocusEvent) => void;
-    focusOut: (event: FocusEvent) => void;
-    panelFocusIn: () => void;
-    panelFocusOut: (event: FocusEvent) => void;
-    click: (event: MouseEvent) => void;
-    contextmenu: (event: MouseEvent) => void;
-    key: (event: KeyboardEvent) => void;
-    afterEnter: () => Promise<void>;
-    afterLeave: () => Promise<void>;
-    inactive: () => void;
-    request: (value: boolean, restore?: boolean) => Promise<boolean>;
-    show: () => Promise<boolean>;
-    hide: () => Promise<boolean>;
-    toggle: () => Promise<boolean>;
-    updatePosition: () => void;
-    focus: () => void | undefined;
 };

package/dist/types/composables/usePopupSurfaceInteractions.d.ts

@@ -0,0 +1,35 @@
+import { type Ref } from "vue";
+import type { HysPopupSurfaceProps } from "./popupSurface";
+import type { FloatingAnchor, useFloating } from "./useFloating";
+export declare const popupFocusControls = "button,a[href],input,select,textarea,[tabindex]:not([tabindex=\"-1\"]),[contenteditable=\"true\"]";
+export type PopupCloseSource = "trigger" | "outside" | "escape" | "tab" | "anchor" | "auto" | "programmatic";
+export declare function usePopupSurfaceInteractions(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", { available, anchor, actualReference, panel, floating, restoreReferenceFocus, request, allowTabExit, }: {
+    available: Readonly<Ref<boolean>>;
+    anchor: Readonly<Ref<FloatingAnchor | undefined>>;
+    actualReference: Readonly<Ref<HTMLElement | undefined>>;
+    panel: Readonly<Ref<HTMLElement | undefined>>;
+    floating: Pick<ReturnType<typeof useFloating>, "open" | "isTop" | "restoringFocus">;
+    restoreReferenceFocus: () => void;
+    request: (open: boolean, restore?: boolean, source?: PopupCloseSource) => Promise<boolean>;
+    allowTabExit?: boolean;
+}): {
+    clearDelays: () => void;
+    clearAuto: () => void;
+    resetReasons: () => void;
+    reset: () => void;
+    startAuto: () => void;
+    tab: (event: KeyboardEvent) => Promise<void>;
+    handlers: {
+        pointerEnter: () => void;
+        pointerLeave: () => void;
+        panelEnter: () => void;
+        panelLeave: () => void;
+        focusIn: (event: FocusEvent) => void;
+        focusOut: (event: FocusEvent) => void;
+        panelFocusIn: () => void;
+        panelFocusOut: (event: FocusEvent) => void;
+        click: (event: MouseEvent) => void;
+        contextmenu: (event: MouseEvent) => void;
+        key: (event: KeyboardEvent) => void;
+    };
+};

package/dist/types/composables/useSplitPaneDrag.d.ts

@@ -5,10 +5,10 @@ interface DragSettings {
     initial: number;
     constrain: (value: number) => number;
 }
-export declare function useSplitPaneDrag(update: (value: number) => void, ended: (value: number, cancelled: boolean, notify: boolean) => void): {
+export declare function useSplitPaneDrag(update: (value: number) => void, ended: (value: number, cancelled: boolean, notify: boolean, byInput: boolean) => void): {
     start: (event: PointerEvent, settings: DragSettings) => boolean;
     cancel: (event: PointerEvent) => void;
-    finish: (cancelled: boolean, notify?: boolean) => void;
+    finish: (cancelled: boolean, notify?: boolean, byInput?: boolean) => void;
     active: () => boolean;
 };
 export {};

package/dist/types/composables/useSvgInstanceId.d.ts

@@ -0,0 +1 @@
+export declare function useSvgInstanceId(suffix: string): import("vue").Ref<string, string>;

package/dist/types/composables/useTable.d.ts

@@ -19,6 +19,7 @@ export declare function useTable<T extends object>(props: HysTableProps<T>, colu
     selectionPage: import("vue").ComputedRef<TableNode<T>[]>;
     sorts: import("vue").ComputedRef<HysTableSort[]>;
     filters: import("vue").ComputedRef<HysTableFilters>;
+    search: import("vue").ComputedRef<string>;
     processed: import("vue").ComputedRef<{
         roots: TableNode<T>[];
         children: Map<string, TableNode<T>[]>;
@@ -47,6 +48,7 @@ export declare function useTable<T extends object>(props: HysTableProps<T>, colu
     setSort: (value: HysTableSort | readonly HysTableSort[] | null) => void;
     setFilter: (key: string, values: readonly HysTableFilterValue[]) => void;
     clearFilter: (keys?: readonly string[]) => void;
+    setSearch: (value: string) => void;
     requestPage: (n: number, action?: "page" | "pageSize") => void;
     changeSize: (n: number) => void;
     toggleRowSelection: (value: T | HysTableKey, checked?: boolean, options?: boolean | HysTableRowSelectionOptions) => Promise<boolean>;

package/dist/types/composables/useTabularRowNavigation.d.ts

@@ -0,0 +1,18 @@
+export declare function useTabularRowNavigation(options: {
+    enabled: () => boolean;
+    table: () => HTMLElement | null | undefined;
+    tokens: () => readonly string[];
+    attribute: string;
+    toggle: (token: string) => boolean;
+}): {
+    focusRow: (token: string) => boolean;
+    rowNavigationAttrs: (token: string) => {
+        tabindex: number;
+        onFocus: () => void;
+        onKeydown: (event: KeyboardEvent) => void;
+    } | {
+        tabindex?: undefined;
+        onFocus?: undefined;
+        onKeydown?: undefined;
+    };
+};