hys-ui 0.1.1 → 0.3.0

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

@@ -0,0 +1,162 @@
+import { type ComputedRef } from "vue";
+import { type HysTreeKey, type HysTreeRecord } from "./tree";
+import type { HysTreeSelectValue } from "./treeSelect";
+import { type CascaderEntry, type HysCascaderProps, type HysCascaderValue, type HysCascaderKey, type HysCascaderPath, type HysCascaderItem } from "./cascader";
+export declare function useCascader<N extends object>(props: HysCascaderProps<N>, disabled: ComputedRef<boolean>, active: ComputedRef<boolean>, emit: (name: string, ...args: any[]) => void, validate: () => void): {
+    engine: {
+        tree: {
+            live: import("vue").Ref<boolean, boolean>;
+            busy: ComputedRef<boolean>;
+            index: ComputedRef<{
+                map: Map<HysTreeKey, HysTreeRecord<CascaderEntry<N>>>;
+                rows: HysTreeRecord<CascaderEntry<N>>[];
+                roots: HysTreeKey[];
+                fields: {
+                    id: string;
+                    label: string;
+                    children: string;
+                    disabled: string;
+                    disableCheckbox: string;
+                    selectable: string;
+                    checkable: string;
+                    icon: string;
+                    hasChildren: string;
+                    isLeaf: string;
+                };
+                invalid: boolean;
+            }>;
+            words: ComputedRef<{
+                search: string;
+                empty: string;
+                noMatch: string;
+                loading: string;
+                retry: string;
+                loadError: string;
+                expand: string;
+                collapse: string;
+                check: string;
+                select: string;
+                clear: string;
+                close: string;
+                tree: string;
+            }>;
+            query: ComputedRef<string>;
+            expanded: ComputedRef<Set<HysTreeKey>>;
+            rawExpanded: ComputedRef<HysTreeKey[]>;
+            selected: ComputedRef<HysTreeKey[]>;
+            selection: ComputedRef<Set<HysTreeKey>>;
+            multiple: ComputedRef<boolean>;
+            visible: ComputedRef<HysTreeRecord<CascaderEntry<N>>[]>;
+            matches: ComputedRef<Set<HysTreeKey>>;
+            checked: ComputedRef<Set<HysTreeKey>>;
+            halfChecked: ComputedRef<Set<HysTreeKey>>;
+            loadingKeys: import("vue").ShallowRef<Set<HysTreeKey>, Set<HysTreeKey>>;
+            failures: import("vue").ShallowRef<Map<HysTreeKey, unknown>, Map<HysTreeKey, unknown>>;
+            ancestors: (key: HysTreeKey) => HysTreeKey[];
+            getNode: (key: HysTreeKey | CascaderEntry<N>) => CascaderEntry<N> | undefined;
+            getNodeInfo: (key: HysTreeKey | CascaderEntry<N>) => HysTreeRecord<CascaderEntry<N>> | undefined;
+            getCheckedKeys: (leafOnly?: boolean) => HysTreeKey[];
+            getCheckedNodes: (leafOnly?: boolean, includeHalf?: boolean) => CascaderEntry<N>[];
+            getHalfCheckedKeys: () => HysTreeKey[];
+            checkInfo: (node?: CascaderEntry<N> | undefined, on?: boolean, event?: Event) => import("./tree").HysTreeCheckInfo<CascaderEntry<N>>;
+            setCheckedKeys: (keys: readonly HysTreeKey[], leafOnly?: boolean) => Promise<boolean>;
+            setChecked: (key: HysTreeKey | CascaderEntry<N>, on: boolean, deep?: boolean, event?: Event) => Promise<boolean>;
+            selectNode: (row: HysTreeRecord<CascaderEntry<N>>, event?: Event) => Promise<boolean>;
+            setSelectedKeys: (keys: readonly HysTreeKey[], node?: CascaderEntry<N> | null, event?: Event) => Promise<boolean>;
+            setCurrentKey: (key: HysTreeKey | null, expandParents?: boolean) => Promise<boolean>;
+            getCurrentKey: () => HysTreeKey;
+            getCurrentNode: () => CascaderEntry<N> | null;
+            setExpandedKeys: (keys: readonly HysTreeKey[]) => Promise<boolean>;
+            expandNode: (key: HysTreeKey, on?: boolean) => Promise<boolean>;
+            filter: (q: string) => void;
+            reloadNode: (key: HysTreeKey) => Promise<boolean>;
+            load: (key: HysTreeKey, force?: boolean) => Promise<boolean>;
+            append: (node: CascaderEntry<N>, parent?: HysTreeKey | CascaderEntry<N> | undefined) => Promise<boolean>;
+            remove: (key: HysTreeKey | CascaderEntry<N>) => Promise<boolean>;
+            insertBefore: (node: CascaderEntry<N>, key: HysTreeKey | CascaderEntry<N>) => Promise<boolean>;
+            insertAfter: (node: CascaderEntry<N>, key: HysTreeKey | CascaderEntry<N>) => Promise<boolean>;
+            updateKeyChildren: (key: HysTreeKey, children: readonly CascaderEntry<N>[]) => Promise<boolean>;
+        };
+        live: import("vue").Ref<boolean, boolean>;
+        current: ComputedRef<HysTreeSelectValue>;
+        values: ComputedRef<HysTreeKey[]>;
+        multiple: ComputedRef<boolean>;
+        query: ComputedRef<string>;
+        items: ComputedRef<import("./treeSelect").HysTreeSelectItem<CascaderEntry<N>>[]>;
+        displayKeys: ComputedRef<HysTreeKey[]>;
+        busy: ComputedRef<boolean>;
+        blocked: ComputedRef<boolean>;
+        words: ComputedRef<{
+            search: string;
+            empty: string;
+            noMatch: string;
+            loading: string;
+            retry: string;
+            loadError: string;
+            expand: string;
+            collapse: string;
+            check: string;
+            select: string;
+            clear: string;
+            close: string;
+            tree: string;
+        }>;
+        remotePending: import("vue").Ref<boolean, boolean>;
+        remoteError: import("vue").ShallowRef<unknown, unknown>;
+        rawNode: (node: CascaderEntry<N>) => CascaderEntry<N>;
+        keyOf: (node: CascaderEntry<N>) => HysTreeKey;
+        item: (key: HysTreeKey) => import("./treeSelect").HysTreeSelectItem<CascaderEntry<N>>;
+        pick: (row: HysTreeRecord<CascaderEntry<N>>, event?: Event) => Promise<boolean>;
+        filter: (text: string) => void;
+        clear: () => Promise<boolean>;
+        removeTag: (key: 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>;
+    };
+    entries: ComputedRef<Map<string, CascaderEntry<N>>>;
+    current: ComputedRef<HysCascaderValue>;
+    multiple: ComputedRef<boolean>;
+    items: ComputedRef<HysCascaderItem<N>[]>;
+    columns: ComputedRef<CascaderEntry<N>[][]>;
+    browsing: ComputedRef<HysTreeKey[]>;
+    anyLevel: ComputedRef<boolean>;
+    blocked: ComputedRef<boolean>;
+    words: ComputedRef<{
+        search: string;
+        empty: string;
+        noMatch: string;
+        loading: string;
+        panel: string;
+        loadError: string;
+        retry: string;
+        clear: string;
+        close: string;
+        level: string;
+        expand: string;
+        remove: string;
+        more: string;
+        limit: string;
+    }>;
+    checking: import("vue").Ref<boolean, boolean>;
+    selectedPaths: ComputedRef<HysTreeKey[][]>;
+    modelKeys: ComputedRef<string[]>;
+    rootPending: import("vue").Ref<boolean, boolean>;
+    rootError: import("vue").ShallowRef<unknown, unknown>;
+    filterPending: import("vue").Ref<boolean, boolean>;
+    filterError: import("vue").ShallowRef<unknown, unknown>;
+    searchResults: ComputedRef<CascaderEntry<N>[]>;
+    item: (key: string) => HysCascaderItem<N>;
+    pick: (key: string, event?: Event, checked?: boolean) => Promise<boolean>;
+    expandPath: (path: HysCascaderPath) => Promise<boolean>;
+    removeTag: (value: HysCascaderPath | HysCascaderKey) => Promise<boolean>;
+    setValue: (value: HysCascaderValue) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    filter: (text: string) => void;
+    reloadRoot: (force?: boolean) => Promise<boolean>;
+    retrySearch: () => Promise<void>;
+    reloadNode: (path: HysCascaderPath) => Promise<boolean>;
+    getCheckedNodes: (leafOnly?: boolean) => N[];
+};
+export type HysCascaderStore<N extends object> = ReturnType<typeof useCascader<N>>;

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/useDatePicker.d.ts

@@ -0,0 +1,79 @@
+import { type ComputedRef } from "vue";
+import { type HysDatePoint, type HysDatePickerProps, type HysDatePickerValue, type HysDatePickerView, type HysDatePickerChange } from "./datePicker";
+export declare function useDatePicker(props: HysDatePickerProps, range: ComputedRef<boolean>, blocked: ComputedRef<boolean>, emit: (name: string, ...args: any[]) => void, validate: () => void): {
+    current: ComputedRef<HysDatePickerValue>;
+    selected: ComputedRef<(HysDatePoint | null)[]>;
+    draft: import("vue").ShallowRef<(HysDatePoint | null)[], (HysDatePoint | null)[]>;
+    stage: import("vue").Ref<"end" | "start", "end" | "start">;
+    preview: import("vue").Ref<number | undefined, number | undefined>;
+    error: import("vue").Ref<string, string>;
+    view: ComputedRef<HysDatePickerView>;
+    rightView: import("vue").Ref<HysDatePickerView, HysDatePickerView>;
+    panels: ComputedRef<number[]>;
+    first: ComputedRef<number>;
+    weekContains: ComputedRef<number>;
+    time: ComputedRef<boolean>;
+    unit: ComputedRef<import("./datePicker").HysDatePickerUnit>;
+    multiple: ComputedRef<boolean>;
+    pattern: ComputedRef<string>;
+    displayPattern: ComputedRef<string>;
+    words: ComputedRef<{
+        today: string;
+        now: string;
+        clear: string;
+        cancel: string;
+        close: string;
+        confirm: string;
+        start: string;
+        end: string;
+        chooseStart: string;
+        chooseEnd: string;
+        invalid: string;
+        week: string;
+        year: string;
+        month: string;
+        back: string;
+        prevMonth: string;
+        nextMonth: string;
+        prevYear: string;
+        nextYear: string;
+        hour: string;
+        minute: string;
+        second: string;
+        empty: string;
+        limit: string;
+    }>;
+    needsConfirm: ComputedRef<boolean>;
+    today: ComputedRef<HysDatePoint>;
+    model: {
+        current: ComputedRef<HysDatePickerValue>;
+        commit: (value: HysDatePickerValue, update: (value: HysDatePickerValue) => void, change: (value: HysDatePickerValue) => void, notifyOnRequest?: boolean) => Promise<boolean>;
+        reset: () => void;
+        invalidate: () => void;
+        isLive: () => boolean;
+    };
+    outputType: ComputedRef<"string" | "date" | "timestamp">;
+    parse: (value: unknown) => HysDatePoint | undefined;
+    boundary: (value: unknown) => HysDatePoint | undefined;
+    points: (value?: HysDatePickerValue | undefined) => (HysDatePoint | null)[];
+    available: (day: number, endpoint?: number, rangeLimit?: boolean) => boolean;
+    periodAvailable: (start: number, end: number, endpoint?: number, rangeLimit?: boolean) => boolean;
+    validTime: (point: HysDatePoint, endpoint: number) => boolean;
+    valid: (list: readonly (HysDatePoint | null)[], enforceLocks?: boolean) => boolean;
+    timeDisabled: (point: HysDatePoint, endpoint: number) => import("./datePicker").HysDateDisabledTime;
+    encode: (list: readonly (HysDatePoint | null)[]) => HysDatePickerValue;
+    describe: (list?: (HysDatePoint | null)[]) => string[];
+    empty: () => HysDatePickerValue;
+    request: (value: HysDatePickerValue, source: HysDatePickerChange["source"], allowClear?: boolean) => Promise<boolean>;
+    begin: () => void;
+    setPanel: (day: number, index?: number) => boolean;
+    setMode: (mode: HysDatePickerView, index?: number) => boolean;
+    choose: (day: number) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    confirm: () => Promise<boolean>;
+    setValue: (value: HysDatePickerValue) => Promise<boolean>;
+    setTime: (index: number, second: number) => boolean;
+    input: (value: string, index?: number) => Promise<boolean>;
+    pickShortcut: (index: number) => boolean;
+    locked: (endpoint: number) => boolean;
+};