hys-ui 0.4.0 → 0.6.0

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

@@ -4,11 +4,12 @@ type __VLS_Slots = {
     suffix?: () => any;
     prepend?: () => any;
     append?: () => any;
-    'clear-icon'?: () => any;
+    "clear-icon"?: () => any;
     count?: (info: HysInputCountInfo) => any;
 };
 type __VLS_Props = Omit<HysInputProps, "type" | "showPassword" | "showPasswordOn" | "passwordVisible" | "defaultPasswordVisible">;
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    element: import("vue").ComputedRef<HTMLTextAreaElement | undefined>;
     input: import("vue").ComputedRef<HTMLTextAreaElement | undefined>;
     textarea: import("vue").ComputedRef<HTMLTextAreaElement | undefined>;
     isComposing: import("vue").ComputedRef<boolean>;
@@ -17,6 +18,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     select: () => void | undefined;
     clear: () => void | undefined;
     resize: () => Promise<void>;
+    resizeTextarea: () => Promise<void>;
+    textareaStyle: import("vue").ComputedRef<import("../../index.js").HysTextareaStyle>;
     setSelectionRange: (start: number, end: number, direction?: "forward" | "backward" | "none") => void | undefined;
     scrollTo: (options: ScrollToOptions) => void | undefined;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
@@ -24,31 +27,39 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     "update:modelValue": (value: string) => any;
     clear: () => any;
     input: (value: string) => any;
+    keydown: (event: KeyboardEvent) => any;
     blur: (event: FocusEvent) => any;
     compositionend: (event: CompositionEvent) => any;
     compositionstart: (event: CompositionEvent) => any;
     compositionupdate: (event: CompositionEvent) => any;
     focus: (event: FocusEvent) => any;
+    mouseenter: (event: MouseEvent) => any;
+    mouseleave: (event: MouseEvent) => any;
     pressEnter: (event: KeyboardEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onChange?: ((value: string) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     onClear?: (() => any) | undefined;
     onInput?: ((value: string) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
     onBlur?: ((event: FocusEvent) => any) | undefined;
     onCompositionend?: ((event: CompositionEvent) => any) | undefined;
     onCompositionstart?: ((event: CompositionEvent) => any) | undefined;
     onCompositionupdate?: ((event: CompositionEvent) => any) | undefined;
     onFocus?: ((event: FocusEvent) => any) | undefined;
+    onMouseenter?: ((event: MouseEvent) => any) | undefined;
+    onMouseleave?: ((event: MouseEvent) => any) | undefined;
     onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
 }>, {
     bordered: boolean;
-    resize: "none" | "both" | "horizontal" | "vertical";
+    resize: "none" | "horizontal" | "vertical" | "both";
+    clearable: boolean;
     showCount: boolean | {
         formatter: (info: HysInputCountInfo) => string;
     };
     countPosition: "inside" | "outside";
     rows: number;
+    validateEvent: boolean;
 }, {}, {}, {}, 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/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: import("./toastTypes").HysToastPosition;
+    open: boolean;
     message: string;
-    position: HysToastPosition;
     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" | "top-center" | "bottom-center" | "custom";
+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/HysTooltip/HysTooltip.vue.d.ts

@@ -33,8 +33,8 @@ declare const __VLS_base: import("vue").DefineComponent<HysTooltipProps, {
     modelValue: boolean;
     destroyOnHide: boolean;
     effect: "dark" | "light";
-    placement: import("../..").Placement;
     open: boolean;
+    placement: import("../..").Placement;
     appendTo: string | false | HTMLElement;
     showDelay: number;
     hideDelay: number;

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

@@ -42,8 +42,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     showArrow: boolean;
     mask: import("../../index.js").HysTourMask;
     type: "default" | "primary";
-    placement: import("../../index.js").Placement;
     open: boolean;
+    placement: import("../../index.js").Placement;
     appendTo: string | false | HTMLElement;
     arrow: boolean | {
         pointAtCenter?: boolean;

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

@@ -16,6 +16,7 @@ declare const __VLS_export: <V extends HysTreeSelectValue = string, N extends ob
             loadedKeys: HysTreeKey[];
         }) => any) | undefined;
         onScroll?: ((event: Event) => any) | undefined;
+        "onValue-change"?: ((value: V, info: HysTreeSelectChange<N>) => any) | undefined;
         "onUpdate:open"?: ((value: boolean) => any) | undefined;
         "onUpdate:searchValue"?: ((value: string) => any) | undefined;
         onDeselect?: ((key: HysTreeKey, node: N, info: unknown) => any) | undefined;
@@ -33,7 +34,6 @@ declare const __VLS_export: <V extends HysTreeSelectValue = string, N extends ob
             node: N;
             error: unknown;
         }) => any) | undefined;
-        "onValue-change"?: ((value: V, info: HysTreeSelectChange<N>) => any) | undefined;
         "onRemove-tag"?: ((key: HysTreeKey, node: N | undefined) => any) | undefined;
         "onSearch-complete"?: ((query: string) => any) | undefined;
         "onSearch-error"?: ((error: unknown, query: string) => any) | undefined;
@@ -101,13 +101,13 @@ declare const __VLS_export: <V extends HysTreeSelectValue = string, N extends ob
         node: N;
         children: readonly N[];
         loadedKeys: HysTreeKey[];
-    }) => void) & ((evt: "scroll", event: Event) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:searchValue", value: string) => void) & ((evt: "deselect", key: HysTreeKey, node: N, info: unknown) => void) & ((evt: "limit", limit: number) => void) & ((evt: "check", info: HysTreeCheckInfo<N>) => void) & ((evt: "update:expandedKeys", keys: HysTreeKey[]) => void) & ((evt: "node-expand", node: N, info: unknown) => void) & ((evt: "node-collapse", node: N, info: unknown) => void) & ((evt: "update:loadedKeys", keys: HysTreeKey[]) => void) & ((evt: "children-loaded", info: {
+    }) => void) & ((evt: "scroll", event: Event) => void) & ((evt: "value-change", value: V, info: HysTreeSelectChange<N>) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:searchValue", value: string) => void) & ((evt: "deselect", key: HysTreeKey, node: N, info: unknown) => void) & ((evt: "limit", limit: number) => void) & ((evt: "check", info: HysTreeCheckInfo<N>) => void) & ((evt: "update:expandedKeys", keys: HysTreeKey[]) => void) & ((evt: "node-expand", node: N, info: unknown) => void) & ((evt: "node-collapse", node: N, info: unknown) => void) & ((evt: "update:loadedKeys", keys: HysTreeKey[]) => void) & ((evt: "children-loaded", info: {
         node: N;
         children: readonly N[];
     }) => void) & ((evt: "load-error", info: {
         node: N;
         error: unknown;
-    }) => void) & ((evt: "value-change", value: V, info: HysTreeSelectChange<N>) => void) & ((evt: "remove-tag", key: HysTreeKey, node: N | undefined) => void) & ((evt: "search-complete", query: string) => void) & ((evt: "search-error", error: unknown, query: string) => void) & ((evt: "visible-change", value: boolean) => void);
+    }) => void) & ((evt: "remove-tag", key: HysTreeKey, node: N | undefined) => void) & ((evt: "search-complete", query: string) => void) & ((evt: "search-error", error: unknown, query: string) => void) & ((evt: "visible-change", value: boolean) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -8,11 +8,11 @@ declare const __VLS_export: <T extends HysUploadItem = HysUploadFile>(__VLS_prop
         onSelect?: ((files: File[]) => any) | undefined;
         onSuccess?: ((response: unknown, file: T) => any) | undefined;
         onAbort?: ((file: T, reason: string) => any) | undefined;
+        onStart?: ((file: T) => any) | undefined;
         onDrop?: ((event: DragEvent) => any) | undefined;
         onError?: ((message: string) => any) | undefined;
         onInvalid?: ((info: HysUploadInvalid<T>) => any) | undefined;
         onPaste?: ((event: ClipboardEvent) => any) | undefined;
-        onStart?: ((file: T) => any) | undefined;
         onRemove?: ((file: T) => any) | undefined;
         onPreview?: ((file: T) => any) | undefined;
         onDownload?: ((file: T) => any) | undefined;
@@ -45,7 +45,7 @@ declare const __VLS_export: <T extends HysUploadItem = HysUploadFile>(__VLS_prop
     }>) => void;
     attrs: any;
     slots: HysUploadSlots<T>;
-    emit: ((evt: "change", files: T[]) => void) & ((evt: "update:modelValue", files: T[]) => void) & ((evt: "progress", percentage: number, file: T) => void) & ((evt: "select", files: File[]) => void) & ((evt: "success", response: unknown, file: T) => void) & ((evt: "abort", file: T, reason: string) => void) & ((evt: "drop", event: DragEvent) => void) & ((evt: "error", message: string) => void) & ((evt: "invalid", info: HysUploadInvalid<T>) => void) & ((evt: "paste", event: ClipboardEvent) => void) & ((evt: "start", file: T) => void) & ((evt: "remove", file: T) => void) & ((evt: "preview", file: T) => void) & ((evt: "download", file: T) => void) & ((evt: "update:fileList", files: T[]) => void) & ((evt: "fileChange", change: HysUploadChange<T>) => void) & ((evt: "uploadError", error: HysUploadError, file: T) => void) & ((evt: "exceed", files: File[]) => void) & ((evt: "removeError", error: Error, file: T) => void);
+    emit: ((evt: "change", files: T[]) => void) & ((evt: "update:modelValue", files: T[]) => void) & ((evt: "progress", percentage: number, file: T) => void) & ((evt: "select", files: File[]) => void) & ((evt: "success", response: unknown, file: T) => void) & ((evt: "abort", file: T, reason: string) => void) & ((evt: "start", file: T) => void) & ((evt: "drop", event: DragEvent) => void) & ((evt: "error", message: string) => void) & ((evt: "invalid", info: HysUploadInvalid<T>) => void) & ((evt: "paste", event: ClipboardEvent) => void) & ((evt: "remove", file: T) => void) & ((evt: "preview", file: T) => void) & ((evt: "download", file: T) => void) & ((evt: "update:fileList", files: T[]) => void) & ((evt: "fileChange", change: HysUploadChange<T>) => void) & ((evt: "uploadError", error: HysUploadError, file: T) => void) & ((evt: "exceed", files: File[]) => void) & ((evt: "removeError", error: Error, file: T) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };