hys-ui 0.5.0 → 0.7.0

package/dist/types/components/HysTabs/useTabsPanels.d.ts

@@ -0,0 +1,14 @@
+import type { HysTabContent, HysTabItem, HysTabValue, HysTabsProps, TabsEmit } from "./tabsTypes";
+interface Resource {
+    state: "loading" | "ready" | "error";
+    content?: HysTabContent;
+    error?: unknown;
+}
+export declare function useTabsPanels(props: () => HysTabsProps, items: () => readonly HysTabItem[], active: () => HysTabValue, emit: TabsEmit): {
+    loaded: import("vue").ShallowReactive<Map<HysTabValue, Resource>>;
+    versions: import("vue").Reactive<Map<HysTabValue, number>>;
+    render: (item: HysTabItem) => boolean;
+    preload: (value: HysTabValue) => Promise<boolean>;
+    reload: (value?: HysTabValue) => Promise<boolean>;
+};
+export {};

package/dist/types/components/HysTabs/useTabsPointer.d.ts

@@ -0,0 +1,30 @@
+import type { HysTabItem, HysTabsProps, HysTabValue } from "./tabsTypes";
+import type { useTabsNav } from "./useTabsNav";
+export declare function useTabsPointer(props: () => HysTabsProps, nav: ReturnType<typeof useTabsNav>, itemByToken: (token: string) => HysTabItem | undefined, canMove: (item: HysTabItem) => boolean, move: (value: HysTabValue, target: HysTabValue, after: boolean) => Promise<boolean>, isVertical: () => boolean, longpress: (item: HysTabItem, event: PointerEvent) => void, swipe: (step: number) => void, animated: () => boolean): {
+    dragging: import("vue").Ref<HysTabValue | undefined, HysTabValue | undefined>;
+    drop: import("vue").Ref<{
+        value: HysTabValue;
+        after: boolean;
+    } | undefined, {
+        value: HysTabValue;
+        after: boolean;
+    } | undefined>;
+    ghost: import("vue").ShallowRef<{
+        label: string;
+        width: number;
+        height: number;
+    } | undefined, {
+        label: string;
+        width: number;
+        height: number;
+    } | undefined>;
+    ghostElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    down: (event: PointerEvent) => void;
+    motion: (event: PointerEvent) => void;
+    finish: (event?: PointerEvent, cancelled?: boolean) => void;
+    cancel: (event: PointerEvent) => void;
+    clickCapture: (event: MouseEvent) => void;
+    swipeDown: (event: PointerEvent) => void;
+    swipeUp: (event: PointerEvent) => void;
+    cancelSwipe: () => void;
+};

package/dist/types/components/HysTabs/useTabsState.d.ts

@@ -0,0 +1,32 @@
+import type { HysTabCloseScope, HysTabItem, HysTabSource, HysTabsProps, HysTabValue, TabsEmit } from "./tabsTypes";
+type Options = () => HysTabsProps;
+export interface ClosedTab {
+    item: HysTabItem;
+    index: number;
+}
+export declare function useTabsState(props: Options, declared: () => readonly HysTabItem[], declarative: () => boolean, emit: TabsEmit, confirmDirty: (items: HysTabItem[], signal: AbortSignal) => Promise<boolean>): {
+    all: import("vue").ComputedRef<HysTabItem[]>;
+    visible: import("vue").ComputedRef<HysTabItem[]>;
+    byKey: import("vue").ComputedRef<Map<HysTabValue, HysTabItem>>;
+    enabled: import("vue").ComputedRef<HysTabItem[]>;
+    active: import("vue").ComputedRef<HysTabValue>;
+    current: import("vue").Ref<HysTabValue | undefined, HysTabValue | undefined>;
+    pending: import("vue").Ref<boolean, boolean>;
+    closing: import("vue").Reactive<Set<HysTabValue>>;
+    recent: import("vue").ShallowRef<HysTabValue[], HysTabValue[]>;
+    closed: import("vue").ShallowRef<ClosedTab[], ClosedTab[]>;
+    select: (value: HysTabValue, source?: HysTabSource) => Promise<boolean>;
+    add: (item?: HysTabItem) => Promise<boolean>;
+    write: (items: HysTabItem[]) => void;
+    canClose: (item: HysTabItem | undefined) => boolean;
+    canMove: (item: HysTabItem | undefined) => boolean;
+    canEdit: () => boolean;
+    rename: (value: HysTabValue, name: string) => Promise<boolean>;
+    pin: (value: HysTabValue, pinned?: boolean) => Promise<boolean>;
+    favorite: (value: HysTabValue, favorite?: boolean) => Promise<boolean>;
+    move: (value: HysTabValue, target: HysTabValue, after?: boolean) => Promise<boolean>;
+    restore: () => Promise<boolean>;
+    closeMany: (scope: HysTabCloseScope | readonly HysTabValue[], anchor?: HysTabValue) => Promise<HysTabValue[]>;
+    close: (value?: HysTabValue) => Promise<boolean>;
+};
+export {};

package/dist/types/components/HysTagInput/HysTagInput.vue.d.ts

@@ -25,8 +25,8 @@ declare const __VLS_base: import("vue").DefineComponent<HysTagInputProps, {
     invalid: (info: HysTagInputInvalid) => any;
     reject: (value: string) => any;
     remove: (value: string) => any;
-    acceptedChange: (values: string[]) => any;
     reorder: (from: number, to: number, values: string[]) => any;
+    acceptedChange: (values: string[]) => any;
 }, string, import("vue").PublicProps, Readonly<HysTagInputProps> & Readonly<{
     onChange?: ((values: string[]) => any) | undefined;
     "onUpdate:modelValue"?: ((values: string[]) => any) | undefined;
@@ -39,8 +39,8 @@ declare const __VLS_base: import("vue").DefineComponent<HysTagInputProps, {
     onInvalid?: ((info: HysTagInputInvalid) => any) | undefined;
     onReject?: ((value: string) => any) | undefined;
     onRemove?: ((value: string) => any) | undefined;
-    onAcceptedChange?: ((values: string[]) => any) | undefined;
     onReorder?: ((from: number, to: number, values: string[]) => any) | undefined;
+    onAcceptedChange?: ((values: string[]) => any) | undefined;
 }>, {
     modelValue: readonly string[];
     trim: boolean;

package/dist/types/components/HysToast/HysToast.vue.d.ts

@@ -1,61 +1,59 @@
-export type HysToastType = 'success' | 'error' | 'info' | 'warning' | 'loading';
-export type HysToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'center' | 'top' | 'bottom';
-type __VLS_Props = {
-    message?: string;
-    type?: HysToastType;
-    duration?: number;
-    closable?: boolean;
-    position?: HysToastPosition;
-    offset?: number;
-    zIndex?: number;
-    showIcon?: boolean;
-    pauseOnHover?: boolean;
-    closeOnEscape?: boolean;
-    repeat?: number;
-    plain?: boolean;
-    teleport?: boolean;
-    appendTo?: string | HTMLElement;
+import type { HysToastActionContext, HysToastActionEvent, HysToastCloseContext, HysToastCloseReason, HysToastContext, HysToastPatch, HysToastProps } from "./toastTypes";
+export type { HysToastPosition, HysToastType } from "./toastTypes";
+type __VLS_Slots = {
+    default?: (context: HysToastActionContext) => unknown;
+    icon?: (context: HysToastActionContext) => unknown;
+    header?: (context: HysToastActionContext) => unknown;
+    footer?: (context: HysToastActionContext) => unknown;
+    action?: (context: HysToastActionContext) => unknown;
 };
-declare function pause(): void;
-declare function resume(): void;
-declare function restart(): void;
-declare function close(): void;
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        icon?: (props: {}) => any;
-    } & {
-        default?: (props: {}) => any;
-    } & {
-        action?: (props: {
-            close: typeof close;
-        }) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+declare function close(reason?: HysToastCloseReason, event?: Event, force?: boolean): Promise<boolean>;
+declare const __VLS_base: import("vue").DefineComponent<HysToastProps, {
     close: typeof close;
-    pause: typeof pause;
-    resume: typeof resume;
-    restart: typeof restart;
+    pause: () => void;
+    resume: () => void;
+    restart: () => void;
+    extend: (milliseconds: number) => void;
     element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    snapshotClock: () => import("./useToastTimer").ToastClock;
+    restoreClock: (clock: import("./useToastTimer").ToastClock) => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    close: () => any;
-    afterClose: () => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onClose?: (() => any) | undefined;
-    onAfterClose?: (() => any) | undefined;
+    click: (event: MouseEvent, context: HysToastContext) => any;
+    close: (context: HysToastCloseContext) => any;
+    afterClose: (context: HysToastCloseContext) => any;
+    action: (event: HysToastActionEvent) => any;
+    show: (context: HysToastContext) => any;
+    update: (patch: HysToastPatch) => any;
+    "update:open": (open: boolean) => any;
+    afterShow: (context: HysToastContext) => any;
+    stateChange: (state: "visible" | "closing" | "closed", context: HysToastContext) => any;
+}, string, import("vue").PublicProps, Readonly<HysToastProps> & Readonly<{
+    onClick?: ((event: MouseEvent, context: HysToastContext) => any) | undefined;
+    onClose?: ((context: HysToastCloseContext) => any) | undefined;
+    onAfterClose?: ((context: HysToastCloseContext) => any) | undefined;
+    onAction?: ((event: HysToastActionEvent) => any) | undefined;
+    onShow?: ((context: HysToastContext) => any) | undefined;
+    onUpdate?: ((patch: HysToastPatch) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onAfterShow?: ((context: HysToastContext) => any) | undefined;
+    onStateChange?: ((state: "visible" | "closing" | "closed", context: HysToastContext) => any) | undefined;
 }>, {
     repeat: number;
-    type: HysToastType;
+    type: import("./toastTypes").HysToastType;
     offset: number;
+    duration: number;
     closable: boolean;
     showIcon: boolean;
-    position: HysToastPosition;
+    position: import("./toastTypes").HysToastPosition;
+    open: boolean;
     message: string;
     zIndex: number;
-    appendTo: string | HTMLElement;
-    pauseOnHover: boolean;
+    appendTo: string | HTMLElement | ShadowRoot;
     teleport: boolean;
+    pauseOnHover: boolean;
+    pauseOnBlur: boolean;
+    interactive: boolean;
+    actionLayout: "footer" | "inline";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/components/HysToast/ToastViewport/ToastViewport.vue.d.ts

@@ -0,0 +1,25 @@
+import { type PropType, type VNode } from "vue";
+import type { createToastQueue } from "../../../composables/toastQueue";
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    queue: {
+        type: PropType<ReturnType<typeof createToastQueue>>;
+        required: true;
+    };
+    skin: {
+        type: PropType<() => Record<string, string>>;
+        required: true;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    queue: {
+        type: PropType<ReturnType<typeof createToastQueue>>;
+        required: true;
+    };
+    skin: {
+        type: PropType<() => Record<string, string>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/HysToast/ToastViewport/useToastStackDisclosure.d.ts

@@ -0,0 +1,16 @@
+interface Disclosure {
+    pinned: boolean;
+    preview: boolean;
+    focused: boolean;
+    suppressHover: boolean;
+}
+export declare function useToastStackDisclosure(): {
+    stacks: import("vue").Reactive<Map<string, Disclosure>>;
+    enter: (key: string, event: PointerEvent) => void;
+    leave: (key: string) => void;
+    toggle: (key: string) => void;
+    focusIn: (key: string) => void;
+    focusOut: (key: string, event: FocusEvent) => void;
+    retain: (keys: Iterable<string>) => void;
+};
+export {};

package/dist/types/components/HysToast/toastPresentation.d.ts

@@ -0,0 +1,8 @@
+import type { CSSProperties } from "vue";
+import type { HysToastLocale, HysToastPosition, HysToastPresentation } from "./toastTypes";
+export declare const toastLocale: HysToastLocale;
+export declare function normalizeToastPosition(position?: HysToastPosition): "center" | "top-right" | "top-left" | "bottom-right" | "bottom-left" | "custom" | "top-center" | "bottom-center";
+export declare const finite: (value: number | undefined, fallback: number) => number;
+export declare const toastDuration: (options: HysToastPresentation) => number;
+export declare function toastPlacement(options: HysToastPresentation): CSSProperties;
+export declare function toastMotion(options: HysToastPresentation): CSSProperties;

package/dist/types/components/HysToast/toastTypes.d.ts

@@ -0,0 +1,212 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import type { HysConfig, HysTheme } from "../../config";
+export type HysToastType = "success" | "error" | "warning" | "info" | "loading" | "default" | "custom";
+export type HysToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right" | "center" | "custom" | "top" | "bottom";
+export type HysToastCloseReason = "timeout" | "button" | "click" | "escape" | "keyboard" | "swipe" | "action" | "api" | "model" | "overflow" | "dispose";
+export type HysToastStatus = "queued" | "visible" | "closing" | "closed";
+export type HysToastAnimation = "fade" | "slide" | "scale" | "spring" | "bounce" | "rotate" | "none";
+export type HysToastDirection = "top" | "bottom" | "left" | "right";
+export type HysToastProgress = number | "indeterminate";
+export type HysToastCoordinates = Pick<CSSProperties, "top" | "right" | "bottom" | "left" | "translate">;
+export interface HysToastMotionPreset {
+    enterFrom: string;
+    leaveTo?: string;
+    opacity?: number;
+}
+export interface HysToastLocale {
+    close: string;
+    copy: string;
+    copied: string;
+    copyFailed: string;
+    expand: string;
+    collapse: string;
+    collapseStack: string;
+    pinStack: string;
+    remaining: (seconds: number) => string;
+    repeat: (count: number) => string;
+    more: (count: number) => string;
+    actionFailed: string;
+    progress: string;
+}
+export interface HysToastPresentation {
+    message?: string;
+    title?: string;
+    type?: HysToastType;
+    duration?: number;
+    persistent?: boolean;
+    closable?: boolean;
+    closeOnClick?: boolean;
+    closeOnEscape?: boolean;
+    keyboardDismiss?: boolean;
+    pauseOnHover?: boolean;
+    pauseOnBlur?: boolean;
+    swipe?: boolean;
+    interactive?: boolean;
+    position?: HysToastPosition;
+    offset?: number;
+    offsetX?: number;
+    offsetY?: number;
+    coordinates?: HysToastCoordinates;
+    zIndex?: number;
+    width?: string | number;
+    showIcon?: boolean;
+    plain?: boolean;
+    glass?: boolean;
+    theme?: HysTheme;
+    toastStyle?: CSSProperties;
+    progressStyle?: CSSProperties;
+    progress?: HysToastProgress;
+    showProgress?: boolean;
+    countdown?: boolean;
+    maxLines?: number;
+    copyable?: boolean;
+    copyText?: string;
+    actionLayout?: "inline" | "footer";
+    actions?: readonly HysToastAction[];
+    animation?: HysToastAnimation | HysToastMotionPreset;
+    direction?: HysToastDirection;
+    animationDuration?: number;
+    easing?: string | ((progress: number) => number);
+    live?: "polite" | "assertive" | "off";
+    locale?: Partial<HysToastLocale>;
+    beforeClose?: (context: HysToastCloseContext) => boolean | void | Promise<boolean | void>;
+}
+export interface HysToastProps extends HysToastPresentation {
+    open?: boolean;
+    teleport?: boolean;
+    appendTo?: string | HTMLElement | ShadowRoot;
+    repeat?: number;
+    paused?: boolean;
+}
+export interface HysToastContext {
+    id?: string;
+    message: string;
+    title?: string;
+    type: HysToastType;
+}
+export interface HysToastCloseContext extends HysToastContext {
+    reason: HysToastCloseReason;
+    event?: Event;
+}
+export interface HysToastActionContext extends HysToastContext {
+    close: () => Promise<boolean>;
+    update: (patch: HysToastPatch) => void;
+    copy: () => Promise<boolean>;
+}
+export interface HysToastAction {
+    id: string;
+    label: string;
+    disabled?: boolean;
+    closeOnSuccess?: boolean;
+    run?: (context: HysToastActionContext) => unknown;
+    success?: HysToastFeedback<unknown>;
+    error?: HysToastFeedback<unknown>;
+}
+export interface HysToastActionEvent extends HysToastContext {
+    action: HysToastAction;
+    status: "start" | "success" | "error";
+    result?: unknown;
+}
+export type HysToastRender = VNodeChild | ((context: HysToastActionContext) => VNodeChild);
+export interface HysToastOptions extends HysToastPresentation {
+    id?: string;
+    content?: HysToastRender;
+    icon?: HysToastRender;
+    header?: HysToastRender;
+    footer?: HysToastRender;
+    renderActions?: HysToastRender;
+    priority?: number;
+    group?: string;
+    grouping?: boolean;
+    dedupe?: "ignore" | "merge";
+    dedupeKey?: string;
+    dedupeWindow?: number;
+    onShow?: (context: HysToastContext) => void;
+    onAfterShow?: (context: HysToastContext) => void;
+    onClose?: (context: HysToastCloseContext) => void;
+    onAfterClose?: (context: HysToastCloseContext) => void;
+    onClick?: (event: MouseEvent, context: HysToastContext) => void;
+    onAction?: (event: HysToastActionEvent) => void;
+    onStateChange?: (snapshot: HysToastSnapshot) => void;
+}
+export type HysToastPatch = string | Partial<Omit<HysToastOptions, "id">>;
+export type HysToastFeedback<T> = HysToastPatch | ((value: T) => HysToastPatch);
+export type HysToastFilter = {
+    type?: HysToastType;
+    group?: string;
+    position?: HysToastPosition;
+    status?: HysToastStatus;
+};
+export interface HysToastSnapshot extends HysToastContext {
+    id: string;
+    status: HysToastStatus;
+    position: HysToastPosition;
+    group?: string;
+    priority: number;
+    repeat: number;
+}
+export interface HysToastConfig extends Omit<HysToastPresentation, "message" | "title" | "theme" | "copyText"> {
+    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;
+}
+export interface HysToastHandle {
+    readonly id: string;
+    readonly closed: Promise<void>;
+    close(): void;
+    update(value: HysToastPatch): void;
+    extend(milliseconds: number): void;
+    pause(): void;
+    resume(): void;
+}
+export interface HysToastTaskContext {
+    handle: HysToastHandle;
+    update: (value: HysToastPatch) => void;
+    progress: (value: HysToastProgress) => void;
+}
+export interface HysToastPromiseOptions<T> {
+    id?: string;
+    options?: HysToastOptions;
+    loading?: HysToastPatch;
+    success?: HysToastFeedback<T>;
+    error?: HysToastFeedback<unknown>;
+}
+export interface HysToastTask<T> {
+    handle: HysToastHandle;
+    promise: Promise<T>;
+}
+type TypedToast = (value: string | Omit<HysToastOptions, "type">) => HysToastHandle;
+export interface HysToastApi {
+    show(value: string | HysToastOptions): HysToastHandle;
+    success: TypedToast;
+    info: TypedToast;
+    warning: TypedToast;
+    error: TypedToast;
+    loading: TypedToast;
+    promise<T>(task: PromiseLike<T> | ((context: HysToastTaskContext) => T | PromiseLike<T>), options?: HysToastPromiseOptions<T>): HysToastTask<T>;
+    close(id: string): void;
+    update(id: string, value: HysToastPatch): void;
+    find(id: string): HysToastSnapshot | undefined;
+    list(filter?: HysToastFilter): HysToastSnapshot[];
+    closeAll(filter?: HysToastFilter): void;
+    closeType(type: HysToastType): void;
+    clearQueue(): void;
+    configure(config: Partial<HysToastConfig>): void;
+}
+export interface HysToastServiceConfig extends HysToastConfig, HysConfig {
+}
+export interface HysToastService extends HysToastApi {
+    dispose(): void;
+}
+export {};

package/dist/types/components/HysToast/useToastActions.d.ts

@@ -0,0 +1,18 @@
+import type { HysToastAction, HysToastActionContext, HysToastActionEvent, HysToastContext, HysToastFeedback, HysToastLocale, HysToastPatch } from "./toastTypes";
+export declare function feedback<T>(value: HysToastFeedback<T> | undefined, result: T): Partial<Omit<import("./toastTypes").HysToastOptions, "id">> | undefined;
+export declare function useToastActions(options: {
+    available: () => boolean;
+    locale: () => HysToastLocale;
+    context: () => HysToastContext;
+    close: () => Promise<boolean>;
+    update: (patch: HysToastPatch) => void;
+    copyText: () => string;
+    emit: (event: HysToastActionEvent) => void;
+}): {
+    busy: import("vue").Ref<string | undefined, string | undefined>;
+    copyStatus: import("vue").Ref<string, string>;
+    copy: () => Promise<boolean>;
+    context: () => HysToastActionContext;
+    run: (action: HysToastAction) => Promise<void>;
+    reset: () => void;
+};

package/dist/types/components/HysToast/useToastSwipe.d.ts

@@ -0,0 +1,11 @@
+import { type Ref } from "vue";
+export declare function useToastSwipe(element: Ref<HTMLElement | undefined>, enabled: () => boolean, dismiss: (event: PointerEvent) => Promise<boolean>): {
+    shift: Ref<number, number>;
+    dragging: Ref<boolean, boolean>;
+    suppressClick: Ref<boolean, boolean>;
+    reset: () => void;
+    start: (event: PointerEvent) => void;
+    move: (event: PointerEvent) => void;
+    end: (event: PointerEvent) => Promise<void>;
+    leave: (event: PointerEvent) => void;
+};

package/dist/types/components/HysToast/useToastTimer.d.ts

@@ -0,0 +1,22 @@
+export type ToastClock = {
+    remaining: number;
+    total: number;
+    expired: boolean;
+};
+export declare function useToastTimer(options: {
+    running: () => boolean;
+    duration: () => number;
+    indicators: () => boolean;
+    pauseOnBlur: () => boolean;
+    expire: () => void;
+}): {
+    remaining: import("vue").Ref<number, number>;
+    total: import("vue").Ref<number, number>;
+    restart: () => void;
+    extend: (milliseconds: number) => void;
+    stop: () => void;
+    snapshot: () => ToastClock;
+    restore(clock: ToastClock): void;
+    pause: () => void;
+    resume: () => void;
+};

package/dist/types/components/HysVirtualTable/HysVirtualTable.vue.d.ts

@@ -5,11 +5,11 @@ declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_p
         onSelectionChange?: ((keys: HysVirtualTableKey[], rows: T[]) => any) | undefined;
         onRowClick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
         "onUpdate:selectedRowKeys"?: ((keys: HysVirtualTableKey[]) => any) | undefined;
-        onSortChange?: ((sort: HysVirtualTableSort | null) => any) | undefined;
         "onUpdate:currentRowKey"?: ((key: HysVirtualTableKey | null) => any) | undefined;
         onCurrentChange?: ((row: T | null, key: HysVirtualTableKey | null) => any) | undefined;
         onRowDblclick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
         onCellClick?: ((context: HysVirtualTableCell<T>, event: MouseEvent) => any) | undefined;
+        onSortChange?: ((sort: HysVirtualTableSort | null) => any) | undefined;
         "onUpdate:sortState"?: ((sort: HysVirtualTableSort | null) => any) | undefined;
         onRangeChange?: ((range: HysVirtualTableRange) => any) | undefined;
         onEndReached?: ((info: {
@@ -60,7 +60,7 @@ declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_p
             selectedRowKeys: HysVirtualTableKey[];
         }): any;
     };
-    emit: ((evt: "scroll", state: HysVirtualTableScroll) => void) & ((evt: "selectionChange", keys: HysVirtualTableKey[], rows: T[]) => void) & ((evt: "rowClick", row: T, index: number, event: MouseEvent) => void) & ((evt: "update:selectedRowKeys", keys: HysVirtualTableKey[]) => void) & ((evt: "sortChange", sort: HysVirtualTableSort | null) => void) & ((evt: "update:currentRowKey", key: HysVirtualTableKey | null) => void) & ((evt: "currentChange", row: T | null, key: HysVirtualTableKey | null) => void) & ((evt: "rowDblclick", row: T, index: number, event: MouseEvent) => void) & ((evt: "cellClick", context: HysVirtualTableCell<T>, event: MouseEvent) => void) & ((evt: "update:sortState", sort: HysVirtualTableSort | null) => void) & ((evt: "rangeChange", range: HysVirtualTableRange) => void) & ((evt: "endReached", info: {
+    emit: ((evt: "scroll", state: HysVirtualTableScroll) => void) & ((evt: "selectionChange", keys: HysVirtualTableKey[], rows: T[]) => void) & ((evt: "rowClick", row: T, index: number, event: MouseEvent) => void) & ((evt: "update:selectedRowKeys", keys: HysVirtualTableKey[]) => void) & ((evt: "update:currentRowKey", key: HysVirtualTableKey | null) => void) & ((evt: "currentChange", row: T | null, key: HysVirtualTableKey | null) => void) & ((evt: "rowDblclick", row: T, index: number, event: MouseEvent) => void) & ((evt: "cellClick", context: HysVirtualTableCell<T>, event: MouseEvent) => void) & ((evt: "sortChange", sort: HysVirtualTableSort | null) => void) & ((evt: "update:sortState", sort: HysVirtualTableSort | null) => void) & ((evt: "rangeChange", range: HysVirtualTableRange) => void) & ((evt: "endReached", info: {
         distance: number;
         total: number;
     }) => void);

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

@@ -1,4 +1,6 @@
 import type { HysPopupMotionProps } from "../motion/popup";
+import type { HysDataGridColumnLayout, HysDataGridColumnLayoutSnapshot } from "../components/HysDataGrid/gridColumnLayout";
+import type { HysDataGridCellContext, HysDataGridClass, HysDataGridContextMenu, HysDataGridHeaderContext, HysDataGridHeaderGroup, HysDataGridPin, HysDataGridRowContext, HysDataGridStyle } from "../components/HysDataGrid/gridPresentation";
 export type HysDataGridKey = string | number;
 export type HysDataGridSort = {
     key: string;
@@ -26,7 +28,11 @@ export interface GridColumn<T extends object = Record<string, unknown>> {
     resizable?: boolean;
     reorderable?: boolean;
     pinned?: "left" | "right";
+    pinnable?: boolean;
     align?: "left" | "center" | "right";
+    headerAlign?: "left" | "center" | "right";
+    headerWrap?: boolean;
+    group?: HysDataGridHeaderGroup;
     summary?: "sum" | "avg" | "min" | "max" | "count";
     editable?: boolean;
 }
@@ -64,14 +70,35 @@ export interface HysDataGridProps<T extends object> extends HysPopupMotionProps
     maxHeight?: number | string;
     scrollToTopOnQuery?: boolean;
     groupable?: boolean;
+    groupBy?: string;
+    defaultGroupBy?: string;
+    groupSummary?: boolean;
     showSummary?: boolean;
+    summaryScope?: "filtered" | "page" | "selected";
     summaryMethod?: (column: GridColumn<T>, rows: readonly T[]) => string | number;
     treeMode?: boolean;
     parentKey?: string;
     editable?: boolean;
+    keyboardNavigation?: boolean;
+    caption?: string;
+    striped?: boolean;
+    highlightCurrentRow?: boolean;
+    currentRowKey?: HysDataGridKey | null;
+    defaultCurrentRowKey?: HysDataGridKey;
+    rowClassName?: HysDataGridClass<HysDataGridRowContext<T>>;
+    rowStyle?: HysDataGridStyle<HysDataGridRowContext<T>>;
+    cellClassName?: HysDataGridClass<HysDataGridCellContext<T>>;
+    cellStyle?: HysDataGridStyle<HysDataGridCellContext<T>>;
+    headerClassName?: HysDataGridClass<HysDataGridHeaderContext<T>>;
+    headerStyle?: HysDataGridStyle<HysDataGridHeaderContext<T>>;
+    contextMenu?: HysDataGridContextMenu<T>;
 }
 export interface HysDataGridInstance {
     resetColumns(): void;
+    getColumnLayout(): HysDataGridColumnLayoutSnapshot;
+    applyColumnLayout(layout: HysDataGridColumnLayout): void;
+    setGroupBy(key: string): void;
+    setGroupsExpanded(expanded: boolean): void;
     getQuery(): HysDataGridQuery;
     setQuery(query: Partial<HysDataGridQuery>): void;
     resetQuery(): void;
@@ -81,6 +108,13 @@ export interface HysDataGridInstance {
     toggleRowSelection(key: HysDataGridKey, checked?: boolean): void;
     scrollTo(options: ScrollToOptions): void;
     scrollToRow(key: HysDataGridKey): boolean;
+    focusRow(key: HysDataGridKey): boolean;
+    getCurrentRowKey(): HysDataGridKey | null;
+    setCurrentRow(key: HysDataGridKey | null): void;
+    setColumnVisibility(key: string, visible: boolean): boolean;
+    pinColumn(key: string, side: HysDataGridPin | null): boolean;
+    resizeColumn(key: string, width: number): boolean;
+    resetColumnWidth(key: string): boolean;
 }
 export type GridRow<T extends object> = {
     row: T;

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

@@ -1,4 +1,4 @@
-import { type Ref } from "vue";
+export { useContainerWidth as useFormWidth } from "./useContainerWidth";
 export type HysFormBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
 export type HysFormGridValue = number | Partial<Record<HysFormBreakpoint, number>>;
 export interface HysFormColSize {
@@ -8,4 +8,3 @@ export interface HysFormColSize {
 export type HysFormCol = HysFormColSize & Partial<Record<HysFormBreakpoint, number | HysFormColSize>>;
 export declare function resolveFormGrid(value: HysFormGridValue | undefined, width: number, fallback?: number): number;
 export declare function resolveFormCol(value: HysFormCol | undefined, width: number): HysFormColSize | undefined;
-export declare function useFormWidth(element: Ref<HTMLElement | undefined>): import("vue").ComputedRef<number>;

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

@@ -0,0 +1,9 @@
+type ReferenceListeners = {
+    [Name in keyof HTMLElementEventMap]?: (event: HTMLElementEventMap[Name]) => void;
+};
+export declare function createPopupReferenceBinding(kind: "tooltip" | "popover", id: string, events: ReferenceListeners): {
+    attach: (node: HTMLElement | undefined, open: boolean) => void;
+    detach: () => void;
+    syncAria: (open: boolean) => void;
+};
+export {};

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

@@ -0,0 +1,7 @@
+import { type CSSProperties, type Ref } from "vue";
+import type { HysPopupSurfaceProps } from "./popupSurface";
+export declare function popupMaximumWidth(props: HysPopupSurfaceProps, kind: "tooltip" | "popover"): string;
+export declare function usePopupSurfaceStyle(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", floatingStyle: Readonly<Ref<CSSProperties>>): {
+    style: import("vue").ComputedRef<CSSProperties>;
+    contentStyle: import("vue").ComputedRef<CSSProperties>;
+};