hys-ui 0.3.0 → 0.5.0

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

@@ -1,11 +1,104 @@
-type __VLS_Props = {
-    value: number;
-    duration?: number;
-    decimals?: number;
+import type { HysAnimatedNumberContext, HysAnimatedNumberProps, HysNumberDigitContext, HysNumberFrame, HysNumberTrend, HysNumberTrigger, HysNumberValue } from "../../composables/animatedNumber";
+type __VLS_Slots = {
+    default?: (context: HysAnimatedNumberContext) => unknown;
+    title?: () => unknown;
+    prefix?: (context: HysAnimatedNumberContext) => unknown;
+    formatter?: (context: HysAnimatedNumberContext) => unknown;
+    suffix?: (context: HysAnimatedNumberContext) => unknown;
+    unit?: (context: HysAnimatedNumberContext) => unknown;
+    digit?: (context: HysNumberDigitContext) => unknown;
+    trend?: (context: HysNumberTrend) => unknown;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+declare function setValue(value: HysNumberValue): void;
+declare const __VLS_base: import("vue").DefineComponent<HysAnimatedNumberProps, {
+    displayValue: import("vue").ComputedRef<string>;
+    remaining: import("vue").Ref<number, number>;
+    frame: Readonly<import("vue").Ref<{
+        readonly value: HysNumberValue;
+        readonly from: HysNumberValue;
+        readonly to: HysNumberValue;
+        readonly progress: number;
+        readonly easedProgress: number;
+        readonly direction: import("../..").HysNumberDirection;
+        readonly status: import("../..").HysNumberStatus;
+        readonly iteration: number;
+    }, {
+        readonly value: HysNumberValue;
+        readonly from: HysNumberValue;
+        readonly to: HysNumberValue;
+        readonly progress: number;
+        readonly easedProgress: number;
+        readonly direction: import("../..").HysNumberDirection;
+        readonly status: import("../..").HysNumberStatus;
+        readonly iteration: number;
+    }>>;
+    trend: import("vue").Ref<{
+        previous: HysNumberValue;
+        target: HysNumberValue;
+        direction: import("../..").HysNumberDirection;
+        delta: string | null;
+        percent: string | null;
+        significant: boolean;
+    }, HysNumberTrend | {
+        previous: HysNumberValue;
+        target: HysNumberValue;
+        direction: import("../..").HysNumberDirection;
+        delta: string | null;
+        percent: string | null;
+        significant: boolean;
+    }>;
+    setValue: typeof setValue;
+    play: () => void;
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+    restart: () => void;
+    reset: () => void;
+    reverse: () => void;
+    seek: (progress: number) => void;
+    finishAnimation: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (remaining: number) => any;
+    "update:modelValue": (target: HysNumberValue) => any;
+    progress: (frame: HysNumberFrame) => any;
+    end: (frame: HysNumberFrame) => any;
+    update: (frame: HysNumberFrame) => any;
+    start: (frame: HysNumberFrame) => any;
+    pause: (frame: HysNumberFrame) => any;
+    resume: (frame: HysNumberFrame) => any;
+    cancel: (frame: HysNumberFrame) => any;
+    loop: (frame: HysNumberFrame) => any;
+    threshold: (trend: HysNumberTrend) => any;
+    "value-change": (trend: HysNumberTrend) => any;
+    finish: () => any;
+}, string, import("vue").PublicProps, Readonly<HysAnimatedNumberProps> & Readonly<{
+    onChange?: ((remaining: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((target: HysNumberValue) => any) | undefined;
+    onProgress?: ((frame: HysNumberFrame) => any) | undefined;
+    onEnd?: ((frame: HysNumberFrame) => any) | undefined;
+    onUpdate?: ((frame: HysNumberFrame) => any) | undefined;
+    onStart?: ((frame: HysNumberFrame) => any) | undefined;
+    onPause?: ((frame: HysNumberFrame) => any) | undefined;
+    onResume?: ((frame: HysNumberFrame) => any) | undefined;
+    onCancel?: ((frame: HysNumberFrame) => any) | undefined;
+    onLoop?: ((frame: HysNumberFrame) => any) | undefined;
+    onThreshold?: ((trend: HysNumberTrend) => any) | undefined;
+    "onValue-change"?: ((trend: HysNumberTrend) => any) | undefined;
+    onFinish?: (() => any) | undefined;
+}>, {
+    format: string;
     duration: number;
-    decimals: number;
+    canPlay: boolean | ((trigger: HysNumberTrigger, target: HysNumberValue) => boolean);
+    visibleOnce: boolean;
+    appearance: "display" | "plain" | "panel";
+    pauseWhenHidden: boolean;
+    grouping: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/HysAnimatedNumber/NumberAnimationCanvas/NumberAnimationCanvas.vue.d.ts

@@ -0,0 +1,19 @@
+import type { HysAnimatedNumberContext } from "../../../composables/animatedNumber";
+import type { ResolvedNumberAnimation } from "../../../composables/numberAnimation";
+import type { NumberPresentation } from "../../../composables/animatedNumberFormat";
+type __VLS_Props = {
+    current: NumberPresentation;
+    start: NumberPresentation;
+    end: NumberPresentation;
+    glyphs: readonly string[];
+    context: HysAnimatedNumberContext;
+    plans: readonly ResolvedNumberAnimation[];
+    digitPlans: Readonly<Record<string, readonly ResolvedNumberAnimation[]>>;
+    intensity: number;
+    motion: boolean;
+    axis?: "vertical" | "horizontal";
+    theme?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/components/HysAnimatedNumber/NumberDigits/NumberDigits.vue.d.ts

@@ -0,0 +1,31 @@
+import type { HysAnimatedNumberContext, HysNumberDigitContext, HysNumberEffect } from "../../../composables/animatedNumber";
+import { type NumberPresentation } from "../../../composables/animatedNumberFormat";
+type __VLS_Props = {
+    current: NumberPresentation;
+    start: NumberPresentation;
+    end: NumberPresentation;
+    glyphs: string[];
+    context: HysAnimatedNumberContext;
+    effect?: HysNumberEffect;
+    axis?: "vertical" | "horizontal";
+    order?: "high-to-low" | "low-to-high";
+    stagger?: number;
+    duration?: number;
+    digitDuration?: number;
+    motion: boolean;
+    timer?: boolean;
+    accessible?: boolean;
+    split?: boolean;
+};
+type __VLS_Slots = {
+    digit?: (scope: HysNumberDigitContext) => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/HysAnimatedNumber/animation/digital.d.ts

@@ -0,0 +1,3 @@
+import { type PaintFrame } from "./paint";
+export declare function paintDigital(frame: PaintFrame, variant: number): void;
+export declare const persistentDisplay: (variant: number) => boolean;

package/dist/types/components/HysAnimatedNumber/animation/morph.d.ts

@@ -0,0 +1,2 @@
+import { type PaintFrame } from "./paint";
+export declare function paintMorph(frame: PaintFrame, variant: number): void;

package/dist/types/components/HysAnimatedNumber/animation/paint.d.ts

@@ -0,0 +1,44 @@
+import type { ResolvedNumberAnimation } from "../../../composables/numberAnimation";
+export interface PaintFrame {
+    ctx: CanvasRenderingContext2D;
+    from: string;
+    to: string;
+    digit: string;
+    section?: "integer" | "fraction";
+    fromIndex: number;
+    toIndex: number;
+    glyphs: readonly string[];
+    width: number;
+    size: number;
+    p: number;
+    strength: number;
+    cycles: number;
+    axis: "horizontal" | "vertical";
+    seed: number;
+    index: number;
+    count: number;
+    color: string;
+    accent: string;
+    plan: ResolvedNumberAnimation;
+}
+export declare const clamp: (p: number) => number;
+export declare const mix: (a: number, b: number, p: number) => number;
+export declare const wave: (p: number) => number;
+export declare const smooth: (p: number) => number;
+export declare const noise: (seed: number, n: number) => number;
+export interface GlyphStyle {
+    x?: number;
+    y?: number;
+    sx?: number;
+    sy?: number;
+    angle?: number;
+    alpha?: number;
+    color?: string;
+    blur?: number;
+    stroke?: number;
+    glow?: number;
+}
+export declare function glyph(frame: PaintFrame, text: string, style?: GlyphStyle): void;
+export declare function rectangle(frame: PaintFrame, x: number, y: number, w: number, h: number, paint: () => void): void;
+export declare function localProgress(p: number, index: number, count: number, spread: number): number;
+export declare const rollingGlyph: (frame: PaintFrame, index: number) => string;

package/dist/types/components/HysAnimatedNumber/animation/particles.d.ts

@@ -0,0 +1,5 @@
+import { type PaintFrame } from "./paint";
+type Point = readonly [number, number];
+export declare function glyphMask(text: string, font: string, size: number, grid?: number): Point[];
+export declare function paintParticles(frame: PaintFrame, variant: number): void;
+export {};

package/dist/types/components/HysAnimatedNumber/animation/paths.d.ts

@@ -0,0 +1,12 @@
+import { type PaintFrame } from "./paint";
+type Point = [x: number, y: number];
+export declare function digitPath(index: number): Point[];
+export declare function tracePath(frame: PaintFrame, points: readonly Point[], progress?: number, options?: {
+    color?: string;
+    width?: number;
+    alpha?: number;
+    smooth?: boolean;
+    close?: boolean;
+    fill?: boolean;
+}): void;
+export {};

package/dist/types/components/HysAnimatedNumber/animation/physics.d.ts

@@ -0,0 +1,2 @@
+import { type PaintFrame } from "./paint";
+export declare function paintPhysics(frame: PaintFrame, variant: number): void;

package/dist/types/components/HysAnimatedNumber/animation/render.d.ts

@@ -0,0 +1,2 @@
+import { type PaintFrame } from "./paint";
+export declare function paintNumberAnimation(frame: PaintFrame): void;

package/dist/types/components/HysAnimatedNumber/animation/reveal.d.ts

@@ -0,0 +1,2 @@
+import { type PaintFrame } from "./paint";
+export declare function paintReveal(frame: PaintFrame, variant: number): void;

package/dist/types/components/HysAnimatedNumber/animation/rolling.d.ts

@@ -0,0 +1,2 @@
+import { type PaintFrame } from "./paint";
+export declare function paintRoll(frame: PaintFrame, variant: number): void;

package/dist/types/components/HysAnimatedNumber/animation/scenarios.d.ts

@@ -0,0 +1,4 @@
+import { type PaintFrame } from "./paint";
+export declare function paintData(frame: PaintFrame, variant: number): void;
+export declare function paintSequence(frame: PaintFrame, variant: number): void;
+export declare function paintSpecial(frame: PaintFrame, variant: number): void;

package/dist/types/components/HysAnimatedNumber/animation/spatial.d.ts

@@ -0,0 +1,2 @@
+import { type PaintFrame } from "./paint";
+export declare function paintSpatial(frame: PaintFrame, variant: number): void;

package/dist/types/components/HysAnimatedNumber/useNumberCountdown.d.ts

@@ -0,0 +1,8 @@
+export declare function useNumberCountdown(deadline: () => number | Date | undefined, format: () => string, pauseWhenHidden: () => boolean, onChange: (remaining: number) => void, onFinish: () => void): {
+    remaining: import("vue").Ref<number, number>;
+    parts: import("vue").ComputedRef<{
+        text: string;
+        numeric: boolean;
+    }[]>;
+    milliseconds: import("vue").ComputedRef<boolean>;
+};

package/dist/types/components/HysAnimatedNumber/useNumberVisuals.d.ts

@@ -0,0 +1,12 @@
+import { type Ref, type StyleValue } from "vue";
+import type { HysAnimatedNumberContext, HysAnimatedNumberProps, HysNumberEffect, HysNumberFrame } from "../../composables/animatedNumber";
+export declare function useNumberVisuals(props: HysAnimatedNumberProps, frame: Readonly<Ref<HysNumberFrame>>, context: Readonly<Ref<HysAnimatedNumberContext>>, motionEnabled: Readonly<Ref<boolean>>, isCountdown: Readonly<Ref<boolean>>, selected: Readonly<Ref<readonly HysNumberEffect[]>>, allowEffects: Readonly<Ref<boolean>>): {
+    from: import("vue").ComputedRef<import("../..").HysNumberValue>;
+    to: import("vue").ComputedRef<import("../..").HysNumberValue>;
+    status: import("vue").ComputedRef<import("../..").HysNumberStatus>;
+    running: import("vue").ComputedRef<boolean>;
+    digitEffect: import("vue").ComputedRef<HysNumberEffect | undefined>;
+    visualStyle: import("vue").ComputedRef<StyleValue>;
+    outgoingStyle: import("vue").ComputedRef<StyleValue>;
+    sliding: import("vue").ComputedRef<boolean>;
+};

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

@@ -33,13 +33,22 @@ declare const __VLS_template: () => {
                 "aria-controls": string | undefined;
                 "aria-activedescendant": string | undefined;
                 "aria-busy": true | undefined;
+                form?: string;
                 type?: string;
+                tabindex?: string | number;
                 autofocus?: boolean;
+                inputmode?: import("vue").InputHTMLAttributes["inputmode"];
+                formatter?: (value: string, info: import("../..").HysInputFormatInfo) => string;
                 resize?: "none" | "both" | "horizontal" | "vertical";
+                round?: boolean;
                 showPassword?: boolean;
                 showPasswordOn?: "click" | "mousedown";
                 passwordVisible?: boolean;
                 defaultPasswordVisible?: boolean;
+                modelModifiers?: import("../..").HysInputModelModifiers;
+                allowClear?: boolean;
+                addonBefore?: string;
+                addonAfter?: string;
                 prefixIcon?: import("vue").Component;
                 suffixIcon?: import("vue").Component;
                 showCount?: boolean | {
@@ -51,7 +60,6 @@ declare const __VLS_template: () => {
                 countGraphemes?: import("../..").HysInputCountStrategy;
                 maxlength?: number | string;
                 minlength?: number | string;
-                formatter?: (value: string, info: import("../..").HysInputFormatInfo) => string;
                 parser?: (value: string) => string | number;
                 allowInput?: (value: string) => boolean;
                 rows?: number;
@@ -60,8 +68,9 @@ declare const __VLS_template: () => {
                     maxRows?: number;
                 };
                 inputProps?: import("vue").InputHTMLAttributes | import("vue").TextareaHTMLAttributes;
+                inputStyle?: import("vue").StyleValue;
+                validateEvent?: boolean;
                 selectOnFocus?: boolean;
-                round?: boolean;
             };
             loading: boolean;
             clear: typeof clear;
@@ -172,9 +181,9 @@ declare const __VLS_base: import("vue").DefineComponent<HysAutocompleteProps, {
     onSearchError?: ((error: unknown, query: string) => any) | undefined;
 }>, {
     bordered: boolean;
+    open: boolean;
     placement: import("../..").Placement;
     defaultValue: string;
-    open: boolean;
     options: readonly HysAutocompleteDataOption[];
     valueKey: string;
     labelKey: string;

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

@@ -80,9 +80,9 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     onOverflowClick?: ((_count: number, _event: MouseEvent) => any) | undefined;
 }>, {
     bordered: boolean;
-    trigger: "click" | "focus" | "hover";
-    placement: Placement;
+    trigger: "click" | "hover" | "focus";
     vertical: boolean;
+    placement: Placement;
     gap: number;
     expandOnHover: boolean;
     showOverflow: boolean;

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

@@ -1,19 +1,70 @@
-import { type Component } from 'vue';
-export type HysButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger' | 'success' | 'warning' | 'info' | 'text' | 'link';
+import { type Component, type VNode } from 'vue';
+export type HysButtonPaletteColor = 'slate' | 'blue' | 'indigo' | 'purple' | 'cyan' | 'teal' | 'green' | 'lime' | 'amber' | 'orange' | 'red' | 'pink';
+export type HysButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger' | 'success' | 'warning' | 'info' | 'text' | 'link' | HysButtonPaletteColor;
+export type HysButtonAppearance = HysButtonVariant | 'default' | '';
+export type HysButtonSize = 'sm' | 'md' | 'lg' | 'small' | 'default' | 'large' | '';
+export interface HysButtonActionContext {
+    signal: AbortSignal;
+    event: MouseEvent;
+    pressed: boolean;
+}
+export type HysButtonAction = (context: HysButtonActionContext) => unknown;
+export type HysButtonActionGuard = (context: HysButtonActionContext) => boolean | void | Promise<boolean | void>;
+export interface HysButtonInstance {
+    readonly element?: HTMLElement;
+    readonly ref?: HTMLElement;
+    readonly busy: boolean;
+    readonly disabled: boolean;
+    readonly size: 'sm' | 'md' | 'lg';
+    readonly type: HysButtonVariant;
+    readonly shouldAddSpace: boolean;
+    focus: () => void;
+    blur: () => void;
+    cancelAction: () => void;
+}
 export interface HysButtonProps {
+    /** 语义外观或内置配色，例如 teal、indigo 和 amber。 */
     variant?: HysButtonVariant;
-    size?: 'sm' | 'md' | 'lg';
+    size?: HysButtonSize;
     disabled?: boolean;
-    loading?: boolean;
+    /** 延迟显示加载图标时，按钮仍会立即阻止重复操作。 */
+    loading?: boolean | {
+        delay: number;
+    };
+    loadingIcon?: string | Component;
+    loadingText?: string;
+    /** 执行期间锁定按钮并接管默认点击行为，组件停用或销毁时取消。 */
+    action?: HysButtonAction;
+    /** 返回 false 时取消操作，支持异步检查。 */
+    beforeAction?: HysButtonActionGuard;
+    actionLoadingDelay?: number;
+    toggle?: boolean;
+    /** 受控按下状态，配合 v-model:pressed 使用。 */
+    pressed?: boolean;
+    defaultPressed?: boolean;
     plain?: boolean;
     round?: boolean;
     circle?: boolean;
+    shape?: 'default' | 'round' | 'circle';
     block?: boolean;
     dashed?: boolean;
     color?: string;
-    icon?: Component;
+    /** 使用深色背景下的配色计算。默认跟随当前主题。 */
+    dark?: boolean;
+    danger?: boolean;
+    ghost?: boolean;
+    text?: boolean;
+    link?: boolean;
+    /** 为文字按钮显示背景。 */
+    bg?: boolean;
+    /** 文案恰好是两个汉字时显示字间距。 */
+    autoInsertSpace?: boolean;
+    /** 自定义根标签或组件，href 默认使用原生链接。 */
+    tag?: string | Component;
+    icon?: string | Component;
     iconPosition?: 'left' | 'right';
-    type?: 'button' | 'submit' | 'reset';
+    /** 外观类型，也兼容原有 button、submit、reset 原生类型。 */
+    type?: HysButtonAppearance | 'button' | 'submit' | 'reset';
     nativeType?: 'button' | 'submit' | 'reset';
     href?: string;
     target?: string;
@@ -22,32 +73,41 @@ export interface HysButtonProps {
     focusable?: boolean;
     ariaLabel?: string;
 }
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        loading?: (props: {}) => any;
-    } & {
-        icon?: (props: {}) => any;
-    } & {
-        default?: (props: {}) => any;
-    } & {
-        icon?: (props: {}) => any;
-    } & {
-        suffix?: (props: {}) => any;
-    };
+type __VLS_Slots = {
+    default?: () => VNode[];
+    icon?: () => VNode[];
+    loading?: () => VNode[];
+    suffix?: () => VNode[];
 };
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare function cancelAction(): void;
 declare const __VLS_base: import("vue").DefineComponent<HysButtonProps, {
-    element: import("vue").Ref<HTMLButtonElement | HTMLAnchorElement | undefined, HTMLButtonElement | HTMLAnchorElement | undefined>;
+    element: import("vue").ComputedRef<HTMLElement | undefined>;
+    ref: import("vue").ComputedRef<HTMLElement | undefined>;
+    busy: import("vue").ComputedRef<boolean>;
+    disabled: import("vue").ComputedRef<boolean>;
+    size: import("vue").ComputedRef<"sm" | "md" | "lg">;
+    type: import("vue").ComputedRef<HysButtonVariant>;
+    shouldAddSpace: import("vue").Ref<boolean, boolean>;
+    cancelAction: typeof cancelAction;
     focus: () => void | undefined;
     blur: () => void | undefined;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     click: (event: MouseEvent) => any;
+    "update:pressed": (value: boolean) => any;
+    pressedChange: (value: boolean) => any;
+    actionSuccess: (result: unknown, context: HysButtonActionContext) => any;
+    actionError: (error: unknown, context: HysButtonActionContext) => any;
 }, string, import("vue").PublicProps, Readonly<HysButtonProps> & Readonly<{
     onClick?: ((event: MouseEvent) => any) | undefined;
+    "onUpdate:pressed"?: ((value: boolean) => any) | undefined;
+    onPressedChange?: ((value: boolean) => any) | undefined;
+    onActionSuccess?: ((result: unknown, context: HysButtonActionContext) => any) | undefined;
+    onActionError?: ((error: unknown, context: HysButtonActionContext) => any) | undefined;
 }>, {
-    type: "button" | "submit" | "reset";
+    dark: boolean;
     focusable: boolean;
-    variant: HysButtonVariant;
+    pressed: boolean;
+    autoInsertSpace: boolean;
     iconPosition: "left" | "right";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

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

@@ -0,0 +1,30 @@
+import { type VNodeChild } from "vue";
+import type { HysButtonAppearance, HysButtonSize, HysButtonVariant } from "../HysButton/HysButton.vue";
+export interface HysButtonGroupProps {
+    variant?: HysButtonVariant;
+    size?: HysButtonSize;
+    type?: HysButtonAppearance;
+    direction?: "horizontal" | "vertical";
+    joined?: boolean;
+    gap?: number | string;
+    wrap?: boolean;
+    block?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+type __VLS_Slots = {
+    default?: () => VNodeChild;
+};
+declare const __VLS_base: import("vue").DefineComponent<HysButtonGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HysButtonGroupProps> & Readonly<{}>, {
+    direction: "horizontal" | "vertical";
+    gap: string | number;
+    joined: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -69,7 +69,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     size: "sm" | "md" | "lg";
     type: "default" | "inner";
     loadingText: string;
-    shadow: "always" | "never" | "hover";
+    shadow: "hover" | "always" | "never";
     tabsLabel: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

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

@@ -18,6 +18,7 @@ declare const __VLS_export: <V extends HysCascaderValue = string[], N extends ob
             level: number;
             event: Event;
         }) => any) | undefined;
+        "onValue-change"?: ((value: V, info: HysCascaderChange<N>) => any) | undefined;
         "onUpdate:open"?: ((value: boolean) => any) | undefined;
         "onUpdate:searchValue"?: ((value: string) => any) | undefined;
         onLimit?: ((limit: number) => any) | undefined;
@@ -37,7 +38,6 @@ declare const __VLS_export: <V extends HysCascaderValue = string[], N extends ob
             path: HysCascaderKey[];
             error: unknown;
         }) => any) | undefined;
-        "onValue-change"?: ((value: V, info: HysCascaderChange<N>) => any) | undefined;
         "onRemove-tag"?: ((path: import("../..").HysTreeKey[], node?: N | undefined) => any) | undefined;
         "onSearch-error"?: ((error: unknown, query: string) => any) | undefined;
         "onUpdate:expandedPath"?: ((path: import("../..").HysTreeKey[]) => any) | undefined;
@@ -109,7 +109,7 @@ declare const __VLS_export: <V extends HysCascaderValue = string[], N extends ob
     }) => void) & ((evt: "scroll", info: {
         level: number;
         event: Event;
-    }) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:searchValue", value: string) => void) & ((evt: "limit", limit: number) => void) & ((evt: "node-expand", node: N, context: {
+    }) => void) & ((evt: "value-change", value: V, info: HysCascaderChange<N>) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:searchValue", value: string) => void) & ((evt: "limit", limit: number) => void) & ((evt: "node-expand", node: N, context: {
         path: HysCascaderKey[];
     }) => void) & ((evt: "node-collapse", node: N, context: {
         path: HysCascaderKey[];
@@ -121,7 +121,7 @@ declare const __VLS_export: <V extends HysCascaderValue = string[], N extends ob
         node: N;
         path: HysCascaderKey[];
         error: unknown;
-    }) => void) & ((evt: "value-change", value: V, info: HysCascaderChange<N>) => void) & ((evt: "remove-tag", path: import("../..").HysTreeKey[], node?: N | undefined) => void) & ((evt: "search-error", error: unknown, query: string) => void) & ((evt: "update:expandedPath", path: import("../..").HysTreeKey[]) => void) & ((evt: "expandChange", path: import("../..").HysTreeKey[], nodes: N[]) => void) & ((evt: "root-load", nodes: readonly N[]) => void) & ((evt: "root-load-error", error: unknown) => void) & ((evt: "visible-change", value: boolean) => void);
+    }) => void) & ((evt: "remove-tag", path: import("../..").HysTreeKey[], node?: N | undefined) => void) & ((evt: "search-error", error: unknown, query: string) => void) & ((evt: "update:expandedPath", path: import("../..").HysTreeKey[]) => void) & ((evt: "expandChange", path: import("../..").HysTreeKey[], nodes: N[]) => void) & ((evt: "root-load", nodes: readonly N[]) => void) & ((evt: "root-load-error", error: unknown) => void) & ((evt: "visible-change", value: boolean) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/types/components/HysCascader/HysCascaderColumn.vue.d.ts

@@ -22,11 +22,11 @@ declare const __VLS_export: <N extends object>(__VLS_props: NonNullable<Awaited<
         retryText: string;
         expandLabel: (entry: CascaderEntry<N>) => string;
     } & {
+        onHover?: ((entry: CascaderEntry<N> | null) => any) | undefined;
+        onKeyboard?: ((event: KeyboardEvent, entry: CascaderEntry<N>, level: number) => any) | undefined;
         onScroll?: ((event: Event) => any) | undefined;
         onRetry?: ((entry: CascaderEntry<N>) => any) | undefined;
-        onHover?: ((entry: CascaderEntry<N> | null) => any) | undefined;
         onChoose?: ((entry: CascaderEntry<N>, event?: Event | undefined, checked?: boolean | undefined) => any) | undefined;
-        onKeyboard?: ((event: KeyboardEvent, entry: CascaderEntry<N>, level: number) => any) | undefined;
         onExpand?: ((entry: CascaderEntry<N>) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
@@ -42,7 +42,7 @@ declare const __VLS_export: <N extends object>(__VLS_props: NonNullable<Awaited<
         "expand-icon"?: (scope: HysCascaderOptionContext<N>) => any;
         loading?: (scope: HysCascaderOptionContext<N>) => any;
     };
-    emit: ((evt: "scroll", event: Event) => void) & ((evt: "retry", entry: CascaderEntry<N>) => void) & ((evt: "hover", entry: CascaderEntry<N> | null) => void) & ((evt: "choose", entry: CascaderEntry<N>, event?: Event | undefined, checked?: boolean | undefined) => void) & ((evt: "keyboard", event: KeyboardEvent, entry: CascaderEntry<N>, level: number) => void) & ((evt: "expand", entry: CascaderEntry<N>) => void);
+    emit: ((evt: "hover", entry: CascaderEntry<N> | null) => void) & ((evt: "keyboard", event: KeyboardEvent, entry: CascaderEntry<N>, level: number) => void) & ((evt: "scroll", event: Event) => void) & ((evt: "retry", entry: CascaderEntry<N>) => void) & ((evt: "choose", entry: CascaderEntry<N>, event?: Event | undefined, checked?: boolean | undefined) => void) & ((evt: "expand", entry: CascaderEntry<N>) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -48,14 +48,14 @@ declare const __VLS_base: import("vue").DefineComponent<HysColorPickerProps, {
 }>, {
     modelValue: string;
     immediate: boolean;
-    placement: import("../../index.js").Placement;
     open: boolean;
+    placement: import("../../index.js").Placement;
+    validateEvent: boolean;
     popupWidth: string | number;
     appendTo: string | false | HTMLElement;
-    showFooter: boolean;
-    validateEvent: boolean;
     showInput: boolean;
     showPresets: boolean;
+    showFooter: 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/HysContextMenu/HysMenuPanel.vue.d.ts

@@ -16,11 +16,11 @@ declare const __VLS_export: <N extends object>(__VLS_props: NonNullable<Awaited<
         context: (row: MenuRow<N>) => HysMenuItemContext<N>;
         tabbable: (row: MenuRow<N>) => number;
     } & {
+        onKeyboard?: ((event: KeyboardEvent) => any) | undefined;
         onScroll?: (() => any) | undefined;
         onChoose?: ((row: MenuRow<N>, event: MouseEvent) => any) | undefined;
         onFocusRow?: ((row: MenuRow<N>) => any) | undefined;
         onHoverRow?: ((row: MenuRow<N>) => any) | undefined;
-        onKeyboard?: ((event: KeyboardEvent) => any) | undefined;
         onBack?: (() => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
@@ -66,7 +66,7 @@ declare const __VLS_export: <N extends object>(__VLS_props: NonNullable<Awaited<
     } & {
         footer?: (props: {}) => any;
     };
-    emit: ((evt: "scroll") => void) & ((evt: "choose", row: MenuRow<N>, event: MouseEvent) => void) & ((evt: "focusRow", row: MenuRow<N>) => void) & ((evt: "hoverRow", row: MenuRow<N>) => void) & ((evt: "keyboard", event: KeyboardEvent) => void) & ((evt: "back") => void);
+    emit: ((evt: "keyboard", event: KeyboardEvent) => void) & ((evt: "scroll") => void) & ((evt: "choose", row: MenuRow<N>, event: MouseEvent) => void) & ((evt: "focusRow", row: MenuRow<N>) => void) & ((evt: "hoverRow", row: MenuRow<N>) => void) & ((evt: "back") => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };