hys-ui 0.1.1 → 0.3.0

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

@@ -1,43 +1,82 @@
+export type HysAccordionKey = string | number;
+export interface HysAccordionItem {
+    id?: HysAccordionKey;
+    title: string;
+    content?: string;
+    disabled?: boolean;
+    forceRender?: boolean;
+    showArrow?: boolean;
+}
 type __VLS_Props = {
-    items: {
-        title: string;
-        content?: string;
-        disabled?: boolean;
-    }[];
+    items: HysAccordionItem[];
     multiple?: boolean;
-    modelValue?: number[];
-    defaultActive?: number[];
+    modelValue?: HysAccordionKey[];
+    defaultActive?: HysAccordionKey[];
     disabled?: boolean;
+    bordered?: boolean;
+    ghost?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    arrowPlacement?: 'left' | 'right';
+    showArrow?: boolean;
+    trigger?: 'header' | 'icon';
+    lazy?: boolean;
+    /** 收起时销毁内容；设为 false 可保留已访问面板的局部状态。 */
+    destroyOnHide?: boolean;
+    beforeToggle?: (key: HysAccordionKey, expanded: boolean) => boolean | void | Promise<boolean | void>;
 };
 declare const __VLS_template: () => {
     __VLS_Slots: {
         title?: (props: {
-            item: {
-                title: string;
-                content?: string;
-                disabled?: boolean;
-            };
+            item: HysAccordionItem;
+            index: number;
+            expanded: boolean;
+        }) => any;
+    } & {
+        icon?: (props: {
+            item: HysAccordionItem;
+            index: number;
+            expanded: boolean;
+        }) => any;
+    } & {
+        icon?: (props: {
+            item: HysAccordionItem;
+            index: number;
+            expanded: boolean;
+        }) => any;
+    } & {
+        extra?: (props: {
+            item: HysAccordionItem;
             index: number;
+            expanded: boolean;
         }) => any;
     } & {
         content?: (props: {
-            item: {
-                title: string;
-                content?: string;
-                disabled?: boolean;
-            };
+            item: HysAccordionItem;
             index: number;
+            expanded: boolean;
         }) => any;
     };
 };
 type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: number[]) => any;
-    change: (value: number[]) => any;
+    change: (value: HysAccordionKey[]) => any;
+    "update:modelValue": (value: HysAccordionKey[]) => any;
+    itemClick: (key: HysAccordionKey, expanded: boolean) => any;
+    guardError: (error: unknown) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: number[]) => any) | undefined;
-    onChange?: ((value: number[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    onChange?: ((value: HysAccordionKey[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: HysAccordionKey[]) => any) | undefined;
+    onItemClick?: ((key: HysAccordionKey, expanded: boolean) => any) | undefined;
+    onGuardError?: ((error: unknown) => any) | undefined;
+}>, {
+    bordered: boolean;
+    size: "sm" | "md" | "lg";
+    arrowPlacement: "left" | "right";
+    showArrow: boolean;
+    trigger: "header" | "icon";
+    lazy: boolean;
+    destroyOnHide: 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;

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

@@ -1,29 +1,39 @@
-type __VLS_Props = {
-    tone?: 'info' | 'success' | 'warning' | 'danger';
-    title?: string;
-    description?: string;
-    closable?: boolean;
-    showIcon?: boolean;
-    center?: boolean;
-    visible?: boolean;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        title?: (props: {}) => any;
-    } & {
-        default?: (props: {}) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+import type { HysAlertProps, HysAlertSlots, HysAlertCloseContext } from "../../composables/feedback";
+type __VLS_Slots = HysAlertSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysAlertProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    visible: import("vue").ComputedRef<boolean>;
+    closing: import("vue").Ref<boolean, boolean>;
+    close: () => Promise<false>;
+    show: () => Promise<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (visible: boolean) => any;
+    "update:visible": (visible: boolean) => any;
+    closeRequest: (context: HysAlertCloseContext) => any;
     close: () => any;
-    "update:visible": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    closeError: (error: Error) => any;
+    afterClose: () => any;
+    visibleChange: (visible: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<HysAlertProps> & Readonly<{
+    "onUpdate:modelValue"?: ((visible: boolean) => any) | undefined;
+    "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+    onCloseRequest?: ((context: HysAlertCloseContext) => any) | undefined;
     onClose?: (() => any) | undefined;
-    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    onCloseError?: ((error: Error) => any) | undefined;
+    onAfterClose?: (() => any) | undefined;
+    onVisibleChange?: ((visible: boolean) => any) | undefined;
 }>, {
-    tone: "info" | "success" | "warning" | "danger";
+    modelValue: boolean;
+    bordered: boolean;
+    size: "sm" | "md" | "lg";
+    transition: import("../..").HysAlertTransition;
+    showIcon: boolean;
     visible: boolean;
+    defaultVisible: boolean;
+    effect: import("../..").HysAlertEffect;
+    closeLabel: string;
+    transitionDuration: number;
+    ariaAtomic: 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/HysAutocomplete/HysAutocomplete.vue.d.ts

@@ -0,0 +1,201 @@
+import { type HysAutocompleteProps, type HysAutocompleteDataOption, type HysAutocompleteItem, type HysAutocompleteRow } from "../../composables/autocomplete";
+declare function focus(options?: FocusOptions): void;
+declare function blur(): void;
+declare function open(): Promise<void>;
+declare function getData(): Promise<void>;
+declare function setValue(value: string | number | null): void;
+declare function clear(): void;
+declare function select(item: HysAutocompleteItem): Promise<void>;
+declare function highlight(index: number): void;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        input?: (props: {
+            value: string;
+            setValue: typeof setValue;
+            inputProps: {
+                disabled: boolean;
+                readonly: boolean;
+                size: "sm" | "md" | "lg";
+                clearable: boolean | undefined;
+                clearIcon: import("vue").Component | undefined;
+                placeholder: string | undefined;
+                label: string | undefined;
+                name: string | undefined;
+                status: "success" | "warning" | "error" | undefined;
+                error: string | undefined;
+                bordered: boolean;
+                id: string | undefined;
+                role: string;
+                autocomplete: string;
+                ariaLabel: string;
+                "aria-autocomplete": string;
+                "aria-expanded": boolean;
+                "aria-controls": string | undefined;
+                "aria-activedescendant": string | undefined;
+                "aria-busy": true | undefined;
+                type?: string;
+                autofocus?: boolean;
+                resize?: "none" | "both" | "horizontal" | "vertical";
+                showPassword?: boolean;
+                showPasswordOn?: "click" | "mousedown";
+                passwordVisible?: boolean;
+                defaultPasswordVisible?: boolean;
+                prefixIcon?: import("vue").Component;
+                suffixIcon?: import("vue").Component;
+                showCount?: boolean | {
+                    formatter: (info: import("../..").HysInputCountInfo) => string;
+                };
+                showWordLimit?: boolean;
+                countPosition?: "inside" | "outside";
+                wordLimitPosition?: "inside" | "outside";
+                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;
+                autosize?: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+                inputProps?: import("vue").InputHTMLAttributes | import("vue").TextareaHTMLAttributes;
+                selectOnFocus?: boolean;
+                round?: boolean;
+            };
+            loading: boolean;
+            clear: typeof clear;
+        }) => any;
+    } & {
+        prefix?: (props: {}) => any;
+    } & {
+        suffix?: (props: {
+            loading: boolean;
+        }) => any;
+    } & {
+        prepend?: (props: {}) => any;
+    } & {
+        append?: (props: {}) => any;
+    } & {
+        'clear-icon'?: (props: {}) => any;
+    } & {
+        header?: (props: {
+            query: string;
+            loading: boolean;
+            options: HysAutocompleteItem[];
+            close: () => void;
+        }) => any;
+    } & {
+        loading?: (props: {
+            query: string;
+        }) => any;
+    } & {
+        error?: (props: {
+            error: unknown;
+            query: string;
+            retry: typeof getData;
+        }) => any;
+    } & {
+        group?: (props: {
+            label: string;
+            group: import("../..").HysAutocompleteGroup | undefined;
+        }) => any;
+    } & {
+        option?: (props: {
+            item: HysAutocompleteItem;
+            option: HysAutocompleteRow;
+            query: string;
+            active: boolean;
+        }) => any;
+    } & {
+        default?: (props: {
+            item: HysAutocompleteItem;
+            option: HysAutocompleteRow;
+            query: string;
+            active: boolean;
+        }) => any;
+    } & {
+        empty?: (props: {
+            query: string;
+        }) => any;
+    } & {
+        footer?: (props: {
+            query: string;
+            loading: boolean;
+            options: HysAutocompleteItem[];
+            close: () => void;
+            clear: typeof clear;
+        }) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import("vue").DefineComponent<HysAutocompleteProps, {
+    input: import("vue").Ref<HTMLInputElement | HTMLTextAreaElement | undefined, HTMLInputElement | HTMLTextAreaElement | undefined>;
+    isOpen: import("vue").Ref<boolean, boolean>;
+    loading: import("vue").ComputedRef<boolean>;
+    highlightedIndex: import("vue").ComputedRef<number>;
+    suggestions: import("vue").ComputedRef<HysAutocompleteItem[]>;
+    focus: typeof focus;
+    blur: typeof blur;
+    open: typeof open;
+    close: () => void;
+    clear: typeof clear;
+    getData: typeof getData;
+    retry: typeof getData;
+    highlight: typeof highlight;
+    select: typeof select;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: string) => any;
+    "update:modelValue": (value: string) => any;
+    search: (query: string) => any;
+    clear: () => any;
+    input: (value: string) => any;
+    select: (item: HysAutocompleteItem, value: string) => any;
+    visibleChange: (open: boolean) => any;
+    blur: (event: FocusEvent) => any;
+    focus: (event: FocusEvent) => any;
+    pressEnter: (event: KeyboardEvent) => any;
+    "update:open": (open: boolean) => any;
+    searchError: (error: unknown, query: string) => any;
+}, string, import("vue").PublicProps, Readonly<HysAutocompleteProps> & Readonly<{
+    onChange?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onSearch?: ((query: string) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onInput?: ((value: string) => any) | undefined;
+    onSelect?: ((item: HysAutocompleteItem, value: string) => any) | undefined;
+    onVisibleChange?: ((open: boolean) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onSearchError?: ((error: unknown, query: string) => any) | undefined;
+}>, {
+    bordered: boolean;
+    placement: import("../..").Placement;
+    defaultValue: string;
+    open: boolean;
+    options: readonly HysAutocompleteDataOption[];
+    valueKey: string;
+    labelKey: string;
+    filterOption: boolean | ((query: string, item: HysAutocompleteItem) => boolean);
+    caseSensitive: boolean;
+    debounce: number;
+    minQueryLength: number;
+    triggerOnFocus: boolean;
+    loopNavigation: boolean;
+    popupMatchWidth: boolean;
+    appendTo: string | false | HTMLElement;
+    listHeight: number;
+    emptyText: string;
+    loadingText: string;
+    errorText: string;
+}, {}, {}, {}, 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/HysAvatar/HysAvatar.vue.d.ts

@@ -1,26 +1,39 @@
-type __VLS_Props = {
-    name?: string;
-    src?: string;
-    size?: number;
-    shape?: 'circle' | 'square';
-    fit?: 'cover' | 'contain' | 'fill';
-    alt?: string;
-};
+import { type HysAvatarProps, type HysAvatarLoadInfo } from "../../composables/avatar";
+declare function reload(): void;
 declare const __VLS_template: () => {
     __VLS_Slots: {
+        placeholder?: (props: {}) => any;
+    } & {
+        fallback?: (props: {
+            error: Event | undefined;
+            reload: typeof reload;
+        }) => any;
+    } & {
+        icon?: (props: {}) => any;
+    } & {
         default?: (props: {}) => any;
     };
 };
 type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    error: (event: Event) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onError?: ((event: Event) => any) | undefined;
+declare const __VLS_base: import("vue").DefineComponent<HysAvatarProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    image: import("vue").Ref<HTMLImageElement | undefined, HTMLImageElement | undefined>;
+    loaded: import("vue").Ref<boolean, boolean>;
+    failed: import("vue").Ref<boolean, boolean>;
+    reload: typeof reload;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (event: Event, info: HysAvatarLoadInfo) => any;
+    load: (event: Event, info: HysAvatarLoadInfo) => any;
+}, string, import("vue").PublicProps, Readonly<HysAvatarProps> & Readonly<{
+    onError?: ((event: Event, info: HysAvatarLoadInfo) => any) | undefined;
+    onLoad?: ((event: Event, info: HysAvatarLoadInfo) => any) | undefined;
 }>, {
+    bordered: boolean;
     name: string;
-    size: number;
-    shape: "circle" | "square";
-    fit: "fill" | "cover" | "contain";
+    draggable: boolean;
+    gap: number;
+    fit: import("../..").HysAvatarFit;
+    autoFit: 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/HysAvatarGroup/HysAvatarGroup.vue.d.ts

@@ -0,0 +1,104 @@
+import type { HysPopupTransition } from '../../motion/popup';
+import { type CSSProperties, type PropType, type SlotsType, type VNode } from "vue";
+import { type HysAvatarOption, type HysAvatarSize } from "../../composables/avatar";
+import { type Placement } from "../../composables/useFloating";
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    popupTransition: PropType<HysPopupTransition>;
+    popupTransitionDuration: NumberConstructor;
+    options: PropType<readonly HysAvatarOption[]>;
+    size: PropType<HysAvatarSize>;
+    shape: PropType<"circle" | "square">;
+    gap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxCount: NumberConstructor;
+    vertical: BooleanConstructor;
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxStyle: PropType<CSSProperties>;
+    maxClass: StringConstructor;
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    trigger: {
+        type: PropType<"hover" | "focus" | "click">;
+        default: string;
+    };
+    showOverflow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandOnHover: BooleanConstructor;
+}>, {
+    open: () => Promise<void>;
+    close: () => void;
+    renderGroup: () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    visibleChange: (_open: boolean) => true;
+    overflowClick: (_count: number, _event: MouseEvent) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    popupTransition: PropType<HysPopupTransition>;
+    popupTransitionDuration: NumberConstructor;
+    options: PropType<readonly HysAvatarOption[]>;
+    size: PropType<HysAvatarSize>;
+    shape: PropType<"circle" | "square">;
+    gap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxCount: NumberConstructor;
+    vertical: BooleanConstructor;
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxStyle: PropType<CSSProperties>;
+    maxClass: StringConstructor;
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    trigger: {
+        type: PropType<"hover" | "focus" | "click">;
+        default: string;
+    };
+    showOverflow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandOnHover: BooleanConstructor;
+}>> & Readonly<{
+    onVisibleChange?: ((_open: boolean) => any) | undefined;
+    onOverflowClick?: ((_count: number, _event: MouseEvent) => any) | undefined;
+}>, {
+    bordered: boolean;
+    trigger: "click" | "focus" | "hover";
+    placement: Placement;
+    vertical: boolean;
+    gap: number;
+    expandOnHover: boolean;
+    showOverflow: boolean;
+}, SlotsType<{
+    default?: () => VNode[];
+    avatar?: (props: {
+        option: HysAvatarOption;
+        index: number;
+    }) => VNode[];
+    overflow?: (props: {
+        count: number;
+        options: HysAvatarOption[];
+    }) => VNode[];
+    content?: (props: {
+        options: HysAvatarOption[];
+        close: () => void;
+    }) => VNode[];
+    empty?: () => VNode[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -1,27 +1,64 @@
+import { type CSSProperties } from "vue";
 type __VLS_Props = {
-    tone?: 'blue' | 'green' | 'orange' | 'red' | 'purple' | 'gray';
-    size?: 'sm' | 'md';
+    tone?: "blue" | "green" | "orange" | "red" | "purple" | "gray";
+    size?: "sm" | "md" | "lg";
     round?: boolean;
     closable?: boolean;
+    closeText?: string;
+    closeLabel?: string;
     dot?: boolean;
     value?: number | string;
     max?: number;
     showZero?: boolean;
+    hidden?: boolean;
+    color?: string;
+    offset?: readonly [number | string, number | string];
+    placement?: "top-right" | "top-left" | "bottom-right" | "bottom-left";
+    badgeStyle?: CSSProperties;
+    badgeClass?: string;
+    status?: "success" | "processing" | "default" | "error" | "warning";
+    text?: string;
+    title?: string;
+    effect?: "light" | "dark" | "plain";
+    checkable?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
 };
 declare const __VLS_template: () => {
     __VLS_Slots: {
         default?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        'close-icon'?: (props: {}) => any;
+    } & {
+        content?: (props: {
+            value: string | number | undefined;
+            displayValue: string | number | undefined;
+        }) => any;
     };
 };
 type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (checked: boolean, event: MouseEvent) => any;
     close: (event: MouseEvent) => any;
+    "update:checked": (checked: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((checked: boolean, event: MouseEvent) => any) | undefined;
     onClose?: ((event: MouseEvent) => any) | undefined;
+    "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
 }>, {
+    size: "sm" | "md" | "lg";
     max: number;
-    tone: "blue" | "green" | "purple" | "orange" | "red" | "gray";
-    size: "sm" | "md";
+    tone: "blue" | "green" | "purple" | "orange" | "gray" | "red";
+    effect: "dark" | "light" | "plain";
+    closeLabel: string;
+    placement: "top-right" | "top-left" | "bottom-right" | "bottom-left";
+    checked: boolean;
+    defaultChecked: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;