hys-ui 0.2.0 → 0.4.0

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

@@ -0,0 +1,68 @@
+import type { Component, CSSProperties, VNode } from "vue";
+import type { HysButtonProps } from "../components/HysButton/HysButton.vue";
+import type { HysPopupMotionProps } from "../motion/popup";
+import type { Placement } from "./useFloating";
+export type HysTourTarget = string | HTMLElement | (() => HTMLElement | null | undefined);
+export type HysTourContent = string | VNode | (() => string | VNode);
+export type HysTourMask = boolean | {
+    color?: string;
+    style?: CSSProperties;
+};
+export interface HysTourGap {
+    /** Pixels around the target, either uniform or [horizontal, vertical]. */
+    offset?: number | [number, number];
+    radius?: number;
+}
+export interface HysTourButtonProps extends HysButtonProps {
+    children?: HysTourContent;
+    onClick?: (event: MouseEvent) => void;
+}
+export interface HysTourAppearance {
+    /** Preferred card placement; flips to the opposite side when space is limited. */
+    placement?: Placement;
+    mask?: HysTourMask;
+    gap?: HysTourGap;
+    showArrow?: boolean;
+    arrow?: boolean | {
+        pointAtCenter?: boolean;
+    };
+    type?: "default" | "primary";
+    contentStyle?: CSSProperties;
+    scrollIntoViewOptions?: boolean | ScrollIntoViewOptions;
+    targetAreaClickable?: boolean;
+    showClose?: boolean;
+    closeIcon?: string | Component;
+    prevButtonProps?: HysTourButtonProps;
+    nextButtonProps?: HysTourButtonProps;
+}
+export interface HysTourStep extends HysTourAppearance {
+    /** An element, CSS selector, or function returning the element. */
+    target?: HysTourTarget;
+    title?: HysTourContent;
+    description?: HysTourContent;
+    cover?: HysTourContent;
+    onClose?: () => void;
+}
+export interface HysTourProps extends HysPopupMotionProps, HysTourAppearance {
+    steps: readonly HysTourStep[];
+    /** Display state alias for v-model:open. */
+    open?: boolean;
+    /** Zero-based step index; supports v-model:current and external navigation. */
+    current?: number;
+    closeOnEscape?: boolean;
+    appendTo?: string | HTMLElement | false;
+    zIndex?: number;
+    skipText?: string;
+    prevText?: string;
+    nextText?: string;
+    finishText?: string;
+}
+export interface HysTourContext {
+    step: HysTourStep | undefined;
+    current: number;
+    total: number;
+    goTo: (index: number) => void;
+    previous: () => void;
+    next: () => void;
+    close: () => void;
+}

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

@@ -32,6 +32,8 @@ export interface HysTransferLocale {
     moveLeft: string;
     dragRight: string;
     dragLeft: string;
+    doubleClickRight?: string;
+    doubleClickLeft?: string;
     dragCount: string;
     moved: string;
     added: string;
@@ -78,7 +80,12 @@ export interface HysTransferProps<T extends object, K extends HysTransferKey> {
     oneWay?: boolean;
     draggable?: boolean;
     dragChecked?: boolean;
+    moveOnDoubleClick?: boolean;
     animated?: boolean;
+    moveAnimation?: "flight" | "fade" | "none";
+    moveDuration?: number;
+    maxAnimatedItems?: number;
+    highlightOnArrival?: boolean;
     size?: "sm" | "md" | "lg";
     listHeight?: number;
     listStyle?: CSSProperties;

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

@@ -1,3 +1,4 @@
+import type { HysPopupTransition } from '../motion/popup';
 import type { CSSProperties, VNodeChild } from "vue";
 export type HysTreeKey = string | number;
 export type HysTreeValue = HysTreeKey | readonly HysTreeKey[] | null;
@@ -104,6 +105,8 @@ export interface HysTreeNodeContext<N extends object> {
     leaf: boolean;
 }
 export interface HysTreeProps<N extends object = TreeNode, V extends HysTreeValue = HysTreeValue> {
+    popupTransition?: HysPopupTransition;
+    popupTransitionDuration?: number;
     nodes: readonly N[];
     modelValue?: V;
     defaultValue?: V;

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

@@ -1,3 +1,4 @@
+import type { HysPopupTransition } from '../motion/popup';
 import type { CSSProperties, VNodeChild } from "vue";
 import { type HysTreeKey, type HysTreeFieldNames, type HysTreeLoadContext, type HysTreeLocale } from "./tree";
 import type { Placement } from "./useFloating";
@@ -44,6 +45,8 @@ export interface HysTreeSelectChange<N extends object = HysTreeSelectNode> {
     event?: Event;
 }
 export interface HysTreeSelectProps<N extends object = HysTreeSelectNode, V extends HysTreeSelectValue = HysTreeSelectValue> {
+    popupTransition?: HysPopupTransition;
+    popupTransitionDuration?: number;
     modelValue?: V;
     defaultValue?: V;
     nodes: readonly N[];

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

@@ -0,0 +1,202 @@
+import type { CSSProperties, VNodeChild } from "vue";
+export type HysUploadStatus = "ready" | "uploading" | "success" | "error";
+export type HysUploadListType = "text" | "picture" | "picture-card";
+export interface HysUploadItem {
+    uid: string;
+    name: string;
+    size?: number;
+    raw?: File;
+    status?: HysUploadStatus;
+    percentage?: number;
+    response?: unknown;
+    error?: Error;
+    url?: string;
+    thumbUrl?: string;
+    type?: string;
+    relativePath?: string;
+}
+/** The original local-file contract remains the default generic. */
+export interface HysUploadFile extends HysUploadItem {
+    size: number;
+    raw: File;
+}
+export type HysUploadChangeType = "select" | "remove" | "clear" | "reset" | "start" | "progress" | "success" | "error" | "abort" | "retry";
+export interface HysUploadChange<T extends HysUploadItem = HysUploadFile> {
+    type: HysUploadChangeType;
+    files: readonly T[];
+    changed: readonly T[];
+}
+export interface HysUploadContext<T extends HysUploadItem = HysUploadFile> {
+    signal: AbortSignal;
+    files: readonly T[];
+}
+export interface HysUploadInvalid<T extends HysUploadItem = HysUploadFile> {
+    reason: "type" | "size" | "validation" | "identity";
+    file: File;
+    message: string;
+    files: readonly T[];
+}
+export interface HysUploadError extends Error {
+    status?: number;
+    response?: unknown;
+    url?: string;
+    method?: string;
+    kind?: "http" | "network" | "timeout" | "configuration" | "custom";
+}
+export type HysUploadDataScalar = string | number | boolean | Blob | null | undefined;
+export type HysUploadData = Record<string, HysUploadDataScalar | readonly HysUploadDataScalar[]>;
+export interface HysUploadRequestOptions<T extends HysUploadItem = HysUploadFile> extends HysUploadContext<T> {
+    file: T;
+    body: Blob;
+    action: string;
+    method: string;
+    name: string;
+    headers: Record<string, string>;
+    data: HysUploadData;
+    withCredentials: boolean;
+    timeout: number;
+    onProgress: (percentage: number) => void;
+    onSuccess: (response: unknown) => void;
+    onError: (error: unknown) => void;
+}
+export type HysUploadRequestResult = void | Promise<unknown> | (() => void) | {
+    abort?: () => void;
+    promise?: Promise<unknown>;
+};
+export interface HysUploadLocale {
+    choose: string;
+    drag: string;
+    checking: string;
+    localHint: string;
+    uploadHint: string;
+    files: string;
+    ready: string;
+    uploading: string;
+    success: string;
+    error: string;
+    queued: string;
+    removing: string;
+    submit: string;
+    abort: string;
+    retry: string;
+    clear: string;
+    remove: string;
+    preview: string;
+    download: string;
+    empty: string;
+}
+export declare const uploadLocale: HysUploadLocale;
+export interface HysUploadProps<T extends HysUploadItem = HysUploadFile> {
+    fileList?: readonly T[];
+    modelValue?: readonly T[];
+    defaultFileList?: readonly T[];
+    defaultValue?: readonly T[];
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    loading?: boolean;
+    limit?: number;
+    maxSize?: number;
+    drag?: boolean;
+    paste?: boolean;
+    directory?: boolean;
+    showFileList?: boolean;
+    listType?: HysUploadListType;
+    listHeight?: number | string;
+    size?: "sm" | "md" | "lg";
+    showToolbar?: boolean;
+    showPreview?: boolean;
+    showDownload?: boolean;
+    showRemove?: boolean;
+    showRetry?: boolean;
+    openFileDialogOnClick?: boolean;
+    autoUpload?: boolean;
+    concurrency?: number;
+    action?: string | ((file: T, context: HysUploadContext<T>) => string | Promise<string>);
+    method?: string;
+    name?: string;
+    headers?: Record<string, string> | ((file: T, context: HysUploadContext<T>) => Record<string, string> | Promise<Record<string, string>>);
+    data?: HysUploadData | ((file: T, context: HysUploadContext<T>) => HysUploadData | Promise<HysUploadData>);
+    withCredentials?: boolean;
+    timeout?: number;
+    customRequest?: (options: HysUploadRequestOptions<T>) => HysUploadRequestResult;
+    beforeUpload?: (file: File, context: HysUploadContext<T>) => boolean | void | File | Blob | Promise<boolean | void | File | Blob>;
+    beforeRemove?: (file: T, files: readonly T[], context: HysUploadContext<T>) => boolean | void | Promise<boolean | void>;
+    createFile?: (raw: File, uid: string) => T;
+    previewFile?: (file: T, context: HysUploadContext<T>) => string | false | Promise<string | false>;
+    downloadFile?: (file: T, context: HysUploadContext<T>) => void | boolean | string | Promise<void | boolean | string>;
+    locale?: Partial<HysUploadLocale>;
+    ariaLabel?: string;
+    triggerLabel?: string;
+    error?: string;
+    validateEvent?: boolean;
+    listStyle?: CSSProperties;
+}
+export interface HysUploadActions {
+    preview: () => Promise<boolean>;
+    download: () => Promise<boolean>;
+    remove: () => Promise<boolean>;
+    retry: () => Promise<boolean>;
+    abort: () => number;
+}
+export interface HysUploadFileContext<T extends HysUploadItem = HysUploadFile> {
+    file: T;
+    status: HysUploadStatus;
+    percentage: number;
+    queued: boolean;
+    busy: boolean;
+    actions: HysUploadActions;
+    thumbnail?: string;
+}
+export interface HysUploadSlotContext<T extends HysUploadItem = HysUploadFile> {
+    files: readonly T[];
+    busy: boolean;
+    disabled: boolean;
+    uploading: number;
+    queued: number;
+    open: (event?: Event) => void;
+    submit: () => Promise<number>;
+    abort: () => number;
+    clear: () => Promise<boolean>;
+}
+export interface HysUploadSlots<T extends HysUploadItem = HysUploadFile> {
+    default?: (scope: HysUploadSlotContext<T>) => VNodeChild;
+    trigger?: (scope: HysUploadSlotContext<T>) => VNodeChild;
+    tip?: (scope: HysUploadSlotContext<T>) => VNodeChild;
+    toolbar?: (scope: HysUploadSlotContext<T>) => VNodeChild;
+    file?: (scope: HysUploadFileContext<T>) => VNodeChild;
+    item?: (scope: HysUploadFileContext<T>) => VNodeChild;
+    empty?: (scope: HysUploadSlotContext<T>) => VNodeChild;
+    progress?: (scope: HysUploadFileContext<T>) => VNodeChild;
+    preview?: (scope: {
+        file: T;
+        url: string;
+        close: () => void;
+    }) => VNodeChild;
+}
+export interface HysUploadInstance<T extends HysUploadItem = HysUploadFile> {
+    readonly element: HTMLElement | undefined;
+    readonly input: HTMLInputElement | undefined;
+    readonly files: readonly T[];
+    readonly busy: boolean;
+    readonly uploading: number;
+    readonly queued: number;
+    open: (event?: Event) => void;
+    focus: () => void;
+    addFiles: (files: readonly File[]) => Promise<T[]>;
+    getFiles: () => T[];
+    clearFiles: (statuses?: readonly HysUploadStatus[]) => Promise<boolean>;
+    remove: (file: T | string) => Promise<boolean>;
+    submit: (file?: T | string) => Promise<number>;
+    retry: (file: T | string) => Promise<boolean>;
+    abort: (file?: T | string) => number;
+    preview: (file: T | string) => Promise<boolean>;
+    download: (file: T | string) => Promise<boolean>;
+}
+export declare const uploadStatus: (file: HysUploadItem) => HysUploadStatus;
+export declare const uploadPercent: (file: HysUploadItem) => number;
+export declare const uploadImage: (file: HysUploadItem) => boolean;
+export declare function uploadSize(value?: number): string;
+export declare function uploadFailure(error: unknown, kind?: HysUploadError["kind"]): HysUploadError;
+export declare function uploadUrl(value: string | undefined, image?: boolean): string | undefined;

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

@@ -0,0 +1,3 @@
+import { type HysUploadItem, type HysUploadRequestOptions } from "./upload";
+/** A cancellable multipart transport. The browser supplies the multipart boundary. */
+export declare function uploadRequest<T extends HysUploadItem>(options: HysUploadRequestOptions<T>): () => void;

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

@@ -0,0 +1,21 @@
+import { type ComputedRef } from "vue";
+import { type HysAlertProps, type HysAlertSlotContext } from "./feedback";
+export declare function useAlert(props: HysAlertProps, emit: (name: string, ...args: any[]) => void): {
+    skin: ComputedRef<{
+        'data-hys-ui': string;
+        'data-hys-theme': import("..").HysTheme;
+        'data-hys-motion': import("..").HysMotion;
+    }>;
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    live: import("vue").Ref<boolean, boolean>;
+    visible: ComputedRef<boolean>;
+    tone: ComputedRef<import("./feedback").HysAlertTone>;
+    duration: ComputedRef<number>;
+    closing: import("vue").Ref<boolean, boolean>;
+    scope: ComputedRef<HysAlertSlotContext>;
+    close: (reason?: "button" | "api", event?: Event) => Promise<false>;
+    show: () => Promise<boolean>;
+    beforeLeave: (node: Element) => void;
+    afterLeave: (node: Element) => void;
+    restore: (node: Element) => void;
+};

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

@@ -110,7 +110,7 @@ export declare function useCascader<N extends object>(props: HysCascaderProps<N>
         filter: (text: string) => void;
         clear: () => Promise<boolean>;
         removeTag: (key: HysTreeKey) => Promise<boolean>;
-        request: (keys: readonly HysTreeKey[], reason: "clear" | "select" | "check" | "remove" | "api", node?: CascaderEntry<N> | undefined, event?: Event, provided?: HysTreeSelectValue, halfKeys?: HysTreeKey[]) => Promise<boolean>;
+        request: (keys: readonly HysTreeKey[], reason: "clear" | "select" | "api" | "check" | "remove", node?: CascaderEntry<N> | undefined, event?: Event, provided?: HysTreeSelectValue, halfKeys?: HysTreeKey[]) => Promise<boolean>;
         project: (keys: readonly HysTreeKey[]) => HysTreeKey[];
         retrySearch: () => Promise<void>;
         setValue: (value: HysTreeSelectValue) => Promise<boolean>;

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

@@ -0,0 +1,101 @@
+import { type HysColor, type HysColorPickerProps, type HysColorPickerContext } from "./color";
+export declare function useColorPicker(props: HysColorPickerProps, emit: (name: string, ...args: any[]) => void): {
+    attrs: import("vue").Attrs;
+    field: import("./formContext").HysFieldContext | undefined;
+    control: {
+        disabled: import("vue").ComputedRef<boolean>;
+        size: import("vue").ComputedRef<"sm" | "md" | "lg">;
+        label: import("vue").ComputedRef<string | undefined>;
+    };
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    trigger: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    input: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    panel: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    live: import("vue").Ref<boolean, boolean>;
+    draft: import("vue").Ref<string, string>;
+    working: import("vue").Ref<{
+        h: number;
+        s: number;
+        v: number;
+        a: number;
+    }, HysColor | {
+        h: number;
+        s: number;
+        v: number;
+        a: number;
+    }>;
+    hasColor: import("vue").Ref<boolean, boolean>;
+    focused: import("vue").Ref<boolean, boolean>;
+    errorId: string;
+    panelId: string;
+    value: import("vue").ComputedRef<string>;
+    locked: import("vue").ComputedRef<boolean>;
+    format: import("vue").ComputedRef<import("./color").HysColorFormat>;
+    serialized: import("vue").ComputedRef<string>;
+    css: import("vue").ComputedRef<string>;
+    valid: import("vue").ComputedRef<boolean>;
+    dirty: import("vue").ComputedRef<boolean>;
+    status: import("vue").ComputedRef<import("./formContext").HysFormStatus | undefined>;
+    floating: {
+        open: import("vue").Ref<boolean, boolean>;
+        style: import("vue").ComputedRef<{
+            zIndex: string;
+        }>;
+        placement: import("vue").Ref<import("./useFloating").Placement, import("./useFloating").Placement>;
+        update: () => void;
+        show: (force?: boolean) => Promise<void>;
+        close: (restore?: boolean, force?: boolean) => void;
+        toggle: () => void | Promise<void>;
+        restoringFocus: import("vue").Ref<boolean, boolean>;
+        schedule: () => void;
+        isTop: () => boolean;
+    };
+    open: import("vue").ComputedRef<boolean>;
+    teleportTo: import("vue").ComputedRef<Element>;
+    presets: import("vue").ComputedRef<{
+        value: string;
+        color: string;
+        parsed: HysColor;
+        key: string;
+    }[]>;
+    context: import("vue").ComputedRef<HysColorPickerContext>;
+    gesture: import("vue").ShallowRef<{
+        node: HTMLElement;
+        id: number;
+        kind: "palette" | "hue" | "alpha";
+        rect: DOMRect;
+        value: string;
+        color: HysColor;
+        hasColor: boolean;
+        lastRequest: string;
+        releaseValidation: () => void;
+    } | undefined, {
+        node: HTMLElement;
+        id: number;
+        kind: "palette" | "hue" | "alpha";
+        rect: DOMRect;
+        value: string;
+        color: HysColor;
+        hasColor: boolean;
+        lastRequest: string;
+        releaseValidation: () => void;
+    } | undefined>;
+    sync: () => void;
+    publish: (final?: boolean) => Promise<boolean>;
+    setColor: (raw: string) => Promise<boolean>;
+    commitText: () => Promise<boolean>;
+    confirm: () => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    cancel: () => void;
+    show: () => Promise<boolean>;
+    hide: (restore?: boolean) => Promise<boolean>;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    focusIn: (event: FocusEvent) => void;
+    focusOut: (event: FocusEvent) => void;
+    start: (event: PointerEvent, kind: "hue" | "alpha" | "palette") => void;
+    move: (event: PointerEvent) => void;
+    end: (event: PointerEvent) => Promise<void>;
+    pointerCancel: (event: PointerEvent) => void;
+    keyboard: (event: KeyboardEvent, kind: "hue" | "alpha" | "palette") => void;
+};

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

@@ -0,0 +1,81 @@
+import { type CSSProperties, type Ref } from "vue";
+import { type HysContextMenuProps, type HysMenuKey, type MenuRow, type HysMenuShowOptions } from "./menu";
+export declare function useContextMenu<N extends object>(props: HysContextMenuProps<N>, root: Ref<HTMLElement | undefined>, layer: Ref<HTMLElement | undefined>, panel: Ref<HTMLElement | undefined>, id: string, emit: (name: string, ...args: any[]) => void): {
+    control: {
+        disabled: import("vue").ComputedRef<boolean>;
+        size: import("vue").ComputedRef<"sm" | "md" | "lg">;
+        label: import("vue").ComputedRef<string | undefined>;
+    };
+    live: Ref<boolean, boolean>;
+    busy: import("vue").ComputedRef<boolean>;
+    graph: import("vue").ComputedRef<{
+        roots: MenuRow<N>[];
+        all: MenuRow<N>[];
+        byKey: Map<string, MenuRow<N>>;
+    }>;
+    triggers: import("vue").ComputedRef<any[]>;
+    open: Ref<boolean, boolean>;
+    branches: import("vue").ComputedRef<MenuRow<N>[]>;
+    menus: import("vue").ComputedRef<MenuRow<N>[][]>;
+    openPath: import("vue").ComputedRef<HysMenuKey[]>;
+    checkedKeys: import("vue").ComputedRef<HysMenuKey[]>;
+    selectedKeys: import("vue").ComputedRef<HysMenuKey[]>;
+    context: (row: MenuRow<N>) => {
+        item: N;
+        value: HysMenuKey | undefined;
+        label: string;
+        path: N[];
+        keys: HysMenuKey[];
+        level: number;
+        disabled: boolean;
+        checked: boolean;
+        selected: boolean;
+        expanded: boolean;
+        submenu: boolean;
+    };
+    tabbable: (row: MenuRow<N>) => 0 | -1;
+    active: Ref<Map<number, HysMenuKey> & Omit<Map<number, HysMenuKey>, keyof Map<any, any>>, Map<number, HysMenuKey> | (Map<number, HysMenuKey> & Omit<Map<number, HysMenuKey>, keyof Map<any, any>>)>;
+    childStyles: import("vue").ShallowRef<Record<number, CSSProperties>, Record<number, CSSProperties>>;
+    floating: {
+        open: Ref<boolean, boolean>;
+        style: import("vue").ComputedRef<{
+            zIndex: string;
+        }>;
+        placement: Ref<import("./useFloating").Placement, import("./useFloating").Placement>;
+        update: () => void;
+        show: (force?: boolean) => Promise<void>;
+        close: (restore?: boolean, force?: boolean) => void;
+        toggle: () => void | Promise<void>;
+        restoringFocus: Ref<boolean, boolean>;
+        schedule: () => void;
+        isTop: () => boolean;
+    };
+    forceHide: () => void;
+    focusableChild: Ref<boolean, boolean>;
+    measureTrigger: () => void;
+    setPanel: (level: number, element?: HTMLElement) => void;
+    scheduleLayout: (updateRoot?: boolean) => void;
+    show: (event?: MouseEvent | KeyboardEvent | HysMenuShowOptions) => Promise<boolean>;
+    hide: (restore?: boolean) => Promise<boolean>;
+    focus: () => void;
+    toggle: () => Promise<boolean>;
+    focusItem: (key: HysMenuKey) => Promise<boolean>;
+    openSubmenu: (key: HysMenuKey, focusChild?: boolean) => Promise<boolean>;
+    closeSubmenus: () => Promise<boolean>;
+    setCheckedKeys: (keys: readonly HysMenuKey[]) => Promise<boolean>;
+    setSelectedKeys: (keys: readonly HysMenuKey[]) => Promise<boolean>;
+    choose: (row: MenuRow<N>, event?: MouseEvent | KeyboardEvent) => Promise<boolean>;
+    setActive: (row: MenuRow<N>, focus?: boolean) => void;
+    hoverRoot: (value: boolean, event?: PointerEvent) => void;
+    enterPanel: () => void;
+    hoverRow: (row: MenuRow<N>) => void;
+    triggerClick: (event: MouseEvent) => void;
+    contextmenu: (event: MouseEvent) => void;
+    triggerFocus: (event: FocusEvent) => void;
+    focusOut: (event: FocusEvent) => void;
+    triggerKey: (event: KeyboardEvent) => void;
+    keyboard: (level: number, event: KeyboardEvent) => void;
+    first: (level?: number, last?: boolean) => void;
+    setPath: (keys: readonly HysMenuKey[], focusChild?: boolean) => Promise<boolean>;
+    getItems: () => N[];
+};

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

@@ -0,0 +1,15 @@
+import { type ComputedRef } from "vue";
+import type { HysDataGridProps, HysDataGridQuery } from "./dataGrid";
+export declare function useDataGridRemote<T extends object>(props: HysDataGridProps<T>, query: ComputedRef<HysDataGridQuery>, onError: (error: unknown) => void): {
+    pending: import("vue").Ref<boolean, boolean>;
+    failure: import("vue").ShallowRef<{
+        error: unknown;
+        query: string;
+    } | undefined, {
+        error: unknown;
+        query: string;
+    } | undefined>;
+    reload: () => Promise<void>;
+    sourceRows: ComputedRef<readonly T[]>;
+    remoteTotal: ComputedRef<number | undefined>;
+};

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

@@ -1,4 +1,17 @@
-import { type Ref } from 'vue';
-export declare function useDialog(open: Ref<boolean>, dialog: Ref<HTMLElement | undefined>, close: () => void): {
-    active: Ref<boolean, boolean>;
+import { type Ref } from "vue";
+interface DialogOptions {
+    lockScroll?: () => boolean;
+    trapFocus?: () => boolean;
+    restoreFocus?: () => boolean;
+    initialFocus?: () => HTMLElement | false | undefined;
+    zIndex?: () => number | undefined;
+    onOpenAutoFocus?: (event: Event) => void;
+    onCloseAutoFocus?: (event: Event) => void;
+    childVisible?: () => boolean;
+}
+export declare function useDialog(open: Ref<boolean>, dialog: Ref<HTMLElement | undefined>, close: () => void, options?: DialogOptions): {
+    active: import("vue").ComputedRef<boolean>;
+    zIndex: import("vue").ComputedRef<number>;
+    focus: () => void;
 };
+export {};

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

@@ -0,0 +1,6 @@
+import { type Ref, type CSSProperties } from "vue";
+import type { HysDrawerProps } from "./drawer";
+export declare function useDrawerPush(props: HysDrawerProps, shown: Readonly<Ref<boolean>>, fullscreen: Readonly<Ref<boolean>>): {
+    pushed: import("vue").ComputedRef<boolean>;
+    style: import("vue").ComputedRef<CSSProperties>;
+};

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

@@ -0,0 +1,27 @@
+import { type Ref } from "vue";
+import { type HysDrawerProps } from "./drawer";
+export declare function useDrawerResize(props: HysDrawerProps, root: Ref<HTMLElement | undefined>, panel: Ref<HTMLElement | undefined>, shown: Readonly<Ref<boolean>>, fullscreen: Readonly<Ref<boolean>>, busy: Readonly<Ref<boolean>>, emit: (name: string, ...args: any[]) => void): {
+    handle: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    resizing: Ref<boolean, boolean>;
+    size: import("vue").ComputedRef<number>;
+    vertical: import("vue").ComputedRef<boolean>;
+    limits: (availableSize?: number) => {
+        min: number;
+        max: number;
+    };
+    model: {
+        current: import("vue").ComputedRef<number | null>;
+        commit: (value: number | null, update: (value: number | null) => void, change: (value: number | null) => void, notifyOnRequest?: boolean) => Promise<boolean>;
+        reset: () => void;
+        invalidate: () => void;
+        isLive: () => boolean;
+    };
+    resolvedSize: import("vue").ComputedRef<number | undefined>;
+    start: (event: PointerEvent) => void;
+    stop: (cancelled?: boolean) => Promise<boolean>;
+    keyboard: (event: KeyboardEvent) => Promise<void>;
+    resizeTo: (value: number | string) => Promise<boolean>;
+    reset: () => Promise<boolean>;
+    measure: () => void;
+    resetAfterClose: () => void;
+};

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

@@ -1,5 +1,13 @@
 import { type Ref } from "vue";
-export type Placement = "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right" | "left";
+export type Placement = "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end";
+export interface FloatingPosition {
+    anchor: DOMRect;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    placement: Placement;
+}
 export interface FloatingAnchor {
     getBoundingClientRect(): DOMRect;
     contains(node: Node | null): boolean;
@@ -7,20 +15,31 @@ export interface FloatingAnchor {
     readonly isConnected: boolean;
 }
 export declare function useFloating(anchor: Readonly<Ref<FloatingAnchor | undefined>>, panel: Ref<HTMLElement | undefined>, options?: {
-    placement?: Placement;
+    placement?: Placement | (() => Placement);
     gap?: number;
     padding?: number;
     matchWidth?: boolean | "min" | (() => boolean | "min");
     width?: () => number | string | undefined;
+    maxWidth?: () => number | string | undefined;
     requestOpen?: (open: boolean, restoreFocus?: boolean) => boolean | void;
     closeOnTab?: boolean;
+    closeOnEscape?: boolean;
+    closeOnOutside?: boolean;
+    autoAdjustOverflow?: boolean;
+    strategy?: "fixed" | "absolute";
+    zIndex?: () => number | undefined;
+    onPosition?: (position: FloatingPosition) => void;
 }): {
     open: Ref<boolean, boolean>;
-    style: Ref<Record<string, string>, Record<string, string>>;
+    style: import("vue").ComputedRef<{
+        zIndex: string;
+    }>;
     placement: Ref<Placement, Placement>;
     update: () => void;
     show: (force?: boolean) => Promise<void>;
     close: (restore?: boolean, force?: boolean) => void;
     toggle: () => void | Promise<void>;
     restoringFocus: Ref<boolean, boolean>;
+    schedule: () => void;
+    isTop: () => boolean;
 };