hys-ui 0.2.0 → 0.3.0

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

@@ -0,0 +1,83 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import type { HysPopupMotionProps } from "../motion/popup";
+import type { Placement } from "./useFloating";
+export type HysPopupPlacement = Placement;
+export type HysPopupTrigger = "hover" | "focus" | "click" | "contextmenu" | "manual";
+export interface HysPopupVirtualReference {
+    getBoundingClientRect: () => DOMRect;
+    contextElement?: HTMLElement;
+}
+export type HysPopupReference = HTMLElement | HysPopupVirtualReference;
+export interface HysPopupSurfaceProps extends HysPopupMotionProps {
+    open?: boolean;
+    modelValue?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    trigger?: HysPopupTrigger | readonly HysPopupTrigger[];
+    triggerKeys?: readonly string[];
+    triggerTabindex?: number;
+    placement?: HysPopupPlacement;
+    offset?: number;
+    autoAdjustOverflow?: boolean;
+    showDelay?: number;
+    hideDelay?: number;
+    autoClose?: number;
+    enterable?: boolean;
+    closeOnEscape?: boolean;
+    closeOnOutside?: boolean;
+    destroyOnHide?: boolean;
+    forceRender?: boolean;
+    appendTo?: string | HTMLElement | false;
+    reference?: HysPopupReference | (() => HysPopupReference | undefined);
+    width?: string | number;
+    maxWidth?: string | number;
+    maxHeight?: string | number;
+    showArrow?: boolean;
+    arrowOffset?: number;
+    effect?: "light" | "dark";
+    color?: string;
+    textColor?: string;
+    overlayClass?: string;
+    overlayStyle?: CSSProperties;
+    contentClass?: string;
+    contentStyle?: CSSProperties;
+    zIndex?: number;
+    ariaLabel?: string;
+}
+export interface HysTooltipProps extends HysPopupSurfaceProps {
+    text?: string;
+}
+export interface HysPopoverProps extends HysPopupSurfaceProps {
+    title?: string;
+    content?: string;
+}
+export interface HysPopupSurfaceContext {
+    open: boolean;
+    show: () => Promise<boolean>;
+    close: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    updatePosition: () => void;
+}
+export interface HysTooltipSlots {
+    default?: (scope: HysPopupSurfaceContext) => VNodeChild;
+    content?: (scope: HysPopupSurfaceContext) => VNodeChild;
+}
+export interface HysPopoverSlots {
+    trigger?: (scope: HysPopupSurfaceContext) => VNodeChild;
+    default?: (scope: HysPopupSurfaceContext) => VNodeChild;
+    title?: (scope: HysPopupSurfaceContext) => VNodeChild;
+}
+export interface HysPopupSurfaceInstance {
+    readonly element: HTMLElement | undefined;
+    readonly referenceElement: HTMLElement | undefined;
+    readonly open: boolean;
+    readonly placement: HysPopupPlacement;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    close: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    updatePosition: () => void;
+    focus: () => void;
+}
+export type HysTooltipInstance = HysPopupSurfaceInstance;
+export type HysPopoverInstance = HysPopupSurfaceInstance;

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

@@ -0,0 +1,92 @@
+import type { VNodeChild } from "vue";
+export type HysProgressType = "line" | "circle" | "dashboard";
+export type HysProgressStatus = "normal" | "success" | "warning" | "error" | "active";
+export type HysProgressSize = "sm" | "md" | "lg";
+export type HysProgressLinecap = "round" | "butt" | "square";
+export type HysProgressGapPosition = "top" | "right" | "bottom" | "left";
+export type HysProgressGradientDirection = number | "to right" | "to left" | "to top" | "to bottom" | "to top right" | "to top left" | "to bottom right" | "to bottom left";
+export interface HysProgressGradientStop {
+    offset: number;
+    color: string;
+}
+export interface HysProgressGradient {
+    from: string;
+    to: string;
+    direction?: HysProgressGradientDirection;
+    stops?: readonly HysProgressGradientStop[];
+}
+export interface HysProgressColorStop {
+    value: number;
+    color: string;
+}
+export type HysProgressColor = string | ((value: number) => string) | readonly HysProgressColorStop[] | readonly string[] | HysProgressGradient;
+export interface HysProgressSuccess {
+    value: number;
+    color?: HysProgressColor;
+}
+export interface HysProgressLabelContext {
+    value: number;
+    successValue: number;
+    status: HysProgressStatus;
+    indeterminate: boolean;
+}
+export interface HysProgressProps {
+    value: number;
+    showLabel?: boolean;
+    color?: HysProgressColor;
+    status?: HysProgressStatus;
+    strokeWidth?: number;
+    type?: HysProgressType;
+    width?: number | string;
+    format?: (value: number, successValue: number) => VNodeChild;
+    indeterminate?: boolean;
+    size?: HysProgressSize;
+    textInside?: boolean;
+    textColor?: string;
+    precision?: number;
+    showStatusIcon?: boolean;
+    trailColor?: string;
+    strokeLinecap?: HysProgressLinecap;
+    success?: HysProgressSuccess;
+    steps?: number;
+    stepGap?: number;
+    gapDegree?: number;
+    gapPosition?: HysProgressGapPosition;
+    striped?: boolean;
+    stripedFlow?: boolean;
+    animated?: boolean;
+    duration?: number;
+    flowDuration?: number;
+    ariaLabel?: string;
+    ariaValueText?: string | ((context: HysProgressLabelContext) => string);
+}
+export interface HysProgressSlots {
+    default?: (context: HysProgressLabelContext) => VNodeChild;
+    icon?: (context: HysProgressLabelContext) => VNodeChild;
+}
+export interface HysProgressInstance {
+    readonly element: HTMLElement | undefined;
+    readonly value: number;
+    readonly successValue: number;
+    readonly status: HysProgressStatus;
+}
+export declare const progressPercent: (value: number | undefined) => number;
+export declare const progressNumber: (value: number | undefined, fallback: number, min: number, max: number) => number;
+export declare const progressStatusColor: (status: HysProgressStatus) => string;
+export type ProgressPaint = {
+    color: string;
+    gradient?: {
+        stops: HysProgressGradientStop[];
+        angle: number;
+    };
+};
+export declare function progressPaint(color: HysProgressColor | undefined, value: number, fallback: string): ProgressPaint;
+export declare function progressCssPaint(paint: ProgressPaint): string;
+export declare function progressGradientCoordinates(degrees: number): {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export declare function progressArc(radius: number, start: number, degrees: number): string;
+export declare const progressId: () => string;

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

@@ -29,6 +29,8 @@ export interface HysSelectInstance {
     close: () => void;
     scrollTo: (value: HysSelectValue) => void;
     retry: () => void;
+    selectAll: () => number;
+    deselectAll: () => number;
     selected: HysSelectOption[];
     query: string;
     isOpen: boolean;

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

@@ -1,3 +1,4 @@
+import type { HysPopupTransition } from '../motion/popup';
 import type { CSSProperties, HTMLAttributes, VNodeChild } from "vue";
 import type { Placement } from "./useFloating";
 export type HysTableKey = string | number;
@@ -147,6 +148,8 @@ export interface HysTableLocale {
     }>;
 }
 export interface HysTableProps<T extends object> {
+    popupTransition?: HysPopupTransition;
+    popupTransitionDuration?: number;
     locale?: Partial<HysTableLocale>;
     columns: readonly HysTableColumn<T>[];
     rows: readonly T[];

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

@@ -0,0 +1,96 @@
+import type { Component, VNodeChild } from "vue";
+import type { HysPopupMotionProps } from "../motion/popup";
+export type HysTagInputReason = "keyboard" | "blur" | "separator" | "paste" | "api";
+export interface HysTagInputAddContext {
+    signal: AbortSignal;
+    values: readonly string[];
+    reason: HysTagInputReason;
+}
+export interface HysTagInputInvalid {
+    value: string;
+    reason: "duplicate" | "max" | "guard" | "error" | "maxlength" | "minlength";
+    error?: Error;
+}
+export interface HysTagInputProps extends HysPopupMotionProps {
+    modelValue?: readonly string[];
+    defaultValue?: readonly string[];
+    max?: number;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    size?: "sm" | "md" | "lg";
+    addOnBlur?: boolean;
+    separator?: string;
+    delimiters?: string | readonly string[] | RegExp;
+    trigger?: "Enter" | "Space" | "Tab" | readonly string[];
+    beforeAdd?: (value: string, context: HysTagInputAddContext) => boolean | void | Promise<boolean | void>;
+    allowDuplicates?: boolean;
+    caseSensitive?: boolean;
+    trim?: boolean;
+    clearable?: boolean;
+    clearIcon?: Component;
+    tagTone?: "primary" | "success" | "warning" | "danger" | "neutral";
+    tagEffect?: "light" | "dark" | "outline";
+    tagRound?: boolean;
+    draggable?: boolean;
+    collapseTags?: boolean;
+    maxCollapseTags?: number;
+    collapseTagsTooltip?: boolean;
+    overflowHeight?: number;
+    maxTagTextLength?: number;
+    maxlength?: number;
+    minlength?: number;
+    ariaLabel?: string;
+    label?: string;
+    name?: string;
+    form?: string;
+    autocomplete?: string;
+    autofocus?: boolean;
+    tabindex?: number;
+    status?: "error" | "warning" | "success";
+    error?: string;
+    validateEvent?: boolean;
+    inputProps?: Record<string, unknown>;
+}
+export interface HysTagInputSlotContext {
+    values: readonly string[];
+    draft: string;
+    disabled: boolean;
+    readonly: boolean;
+    pending: boolean;
+    add: (value?: string | string[]) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+}
+export interface HysTagInputTagContext {
+    value: string;
+    index: number;
+    disabled: boolean;
+    readonly: boolean;
+    remove: () => Promise<boolean>;
+}
+export interface HysTagInputSlots {
+    tag?: (context: HysTagInputTagContext) => VNodeChild;
+    prefix?: (context: HysTagInputSlotContext) => VNodeChild;
+    suffix?: (context: HysTagInputSlotContext) => VNodeChild;
+    "clear-icon"?: (context: HysTagInputSlotContext) => VNodeChild;
+    "remove-icon"?: (context: HysTagInputTagContext) => VNodeChild;
+    "collapse-tag"?: (context: {
+        count: number;
+        values: readonly string[];
+    }) => VNodeChild;
+}
+export interface HysTagInputInstance {
+    readonly element: HTMLElement | undefined;
+    readonly input: HTMLInputElement | undefined;
+    readonly values: readonly string[];
+    readonly draft: string;
+    readonly pending: boolean;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    add: (value?: string | string[]) => Promise<boolean>;
+    remove: (index: number) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    move: (from: number, to: number) => Promise<boolean>;
+    setDraft: (value: string) => void;
+}
+export declare function splitTags(value: string, separator?: string | readonly string[] | RegExp): string[];

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

@@ -0,0 +1,82 @@
+import type { Component, VNodeChild } from "vue";
+export type HysTimelineKey = string | number;
+export type HysTimelineMode = "left" | "right" | "alternate" | "alternate-reverse";
+export type HysTimelinePosition = "left" | "right";
+export type HysTimelineSize = "sm" | "md" | "lg";
+export type HysTimelineTone = "primary" | "success" | "warning" | "danger" | "info" | "neutral";
+export interface HysTimelineItem {
+    id?: HysTimelineKey;
+    key?: HysTimelineKey;
+    title: string;
+    time?: string;
+    dateTime?: string;
+    description?: string;
+    status?: "done" | "current" | "pending";
+    color?: string;
+    label?: string;
+    position?: HysTimelinePosition;
+    tone?: HysTimelineTone;
+    size?: HysTimelineSize | number;
+    hollow?: boolean;
+    loading?: boolean;
+    icon?: Component;
+    hideTime?: boolean;
+    timePlacement?: "top" | "bottom";
+}
+export type HysTimelineFieldNames = Partial<Record<keyof HysTimelineItem, string>>;
+export interface HysTimelineProps<T extends object = HysTimelineItem> {
+    items: readonly T[];
+    reverse?: boolean;
+    pending?: string | boolean;
+    mode?: HysTimelineMode;
+    itemKey?: string | ((item: T, index: number) => HysTimelineKey);
+    fieldNames?: HysTimelineFieldNames;
+    size?: HysTimelineSize;
+    hollow?: boolean;
+    showTime?: boolean;
+    timePlacement?: "top" | "bottom";
+    responsive?: boolean;
+    lineStyle?: "solid" | "dashed" | "dotted";
+    lineColor?: string;
+    pendingPosition?: "start" | "end";
+    pendingLoading?: boolean;
+    pendingText?: string;
+    emptyText?: string;
+    ariaLabel?: string;
+}
+export interface HysTimelineItemContext<T extends object = HysTimelineItem> {
+    item: T;
+    index: number;
+    sourceIndex: number;
+    key: HysTimelineKey;
+    title: string;
+    time: string;
+    description: string;
+    label: string;
+    position: HysTimelinePosition;
+    status: HysTimelineItem["status"];
+    tone: HysTimelineTone;
+    loading: boolean;
+}
+export interface HysTimelinePendingContext {
+    pending: string | boolean | undefined;
+    loading: boolean;
+}
+export interface HysTimelineSlots<T extends object = HysTimelineItem> {
+    item?: (context: HysTimelineItemContext<T>) => VNodeChild;
+    title?: (context: HysTimelineItemContext<T>) => VNodeChild;
+    description?: (context: HysTimelineItemContext<T>) => VNodeChild;
+    time?: (context: HysTimelineItemContext<T>) => VNodeChild;
+    label?: (context: HysTimelineItemContext<T>) => VNodeChild;
+    dot?: (context: HysTimelineItemContext<T>) => VNodeChild;
+    pending?: (context: HysTimelinePendingContext) => VNodeChild;
+    "pending-dot"?: (context: HysTimelinePendingContext) => VNodeChild;
+    empty?: () => VNodeChild;
+}
+export interface HysTimelineInstance<T extends object = HysTimelineItem> {
+    readonly element: HTMLOListElement | undefined;
+    getItems: () => T[];
+}
+export declare function timelineRead(item: object, path: string): unknown;
+export declare const timelineText: (value: unknown) => string;
+export declare const timelineTone: (tone: HysTimelineTone) => string;

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>;