hys-ui 0.2.0 → 0.3.0

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

@@ -43,15 +43,15 @@ declare const __VLS_template: () => {
                 prefixIcon?: import("vue").Component;
                 suffixIcon?: import("vue").Component;
                 showCount?: boolean | {
-                    formatter: (info: import("../../index.js").HysInputCountInfo) => string;
+                    formatter: (info: import("../..").HysInputCountInfo) => string;
                 };
                 showWordLimit?: boolean;
                 countPosition?: "inside" | "outside";
                 wordLimitPosition?: "inside" | "outside";
-                countGraphemes?: import("../../index.js").HysInputCountStrategy;
+                countGraphemes?: import("../..").HysInputCountStrategy;
                 maxlength?: number | string;
                 minlength?: number | string;
-                formatter?: (value: string, info: import("../../index.js").HysInputFormatInfo) => string;
+                formatter?: (value: string, info: import("../..").HysInputFormatInfo) => string;
                 parser?: (value: string) => string | number;
                 allowInput?: (value: string) => boolean;
                 rows?: number;
@@ -98,7 +98,7 @@ declare const __VLS_template: () => {
     } & {
         group?: (props: {
             label: string;
-            group: import("../../index.js").HysAutocompleteGroup | undefined;
+            group: import("../..").HysAutocompleteGroup | undefined;
         }) => any;
     } & {
         option?: (props: {
@@ -151,11 +151,11 @@ declare const __VLS_base: import("vue").DefineComponent<HysAutocompleteProps, {
     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;
-    visibleChange: (open: boolean) => any;
     searchError: (error: unknown, query: string) => any;
 }, string, import("vue").PublicProps, Readonly<HysAutocompleteProps> & Readonly<{
     onChange?: ((value: string) => any) | undefined;
@@ -164,14 +164,15 @@ declare const __VLS_base: import("vue").DefineComponent<HysAutocompleteProps, {
     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;
-    onVisibleChange?: ((open: boolean) => any) | undefined;
     onSearchError?: ((error: unknown, query: string) => any) | undefined;
 }>, {
     bordered: boolean;
+    placement: import("../..").Placement;
     defaultValue: string;
     open: boolean;
     options: readonly HysAutocompleteDataOption[];
@@ -183,7 +184,6 @@ declare const __VLS_base: import("vue").DefineComponent<HysAutocompleteProps, {
     minQueryLength: number;
     triggerOnFocus: boolean;
     loopNavigation: boolean;
-    placement: import("../../index.js").Placement;
     popupMatchWidth: boolean;
     appendTo: string | false | HTMLElement;
     listHeight: number;

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

@@ -1,9 +1,12 @@
+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">;
@@ -42,6 +45,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     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">;
@@ -76,8 +81,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>, {
     bordered: boolean;
     trigger: "click" | "focus" | "hover";
-    vertical: boolean;
     placement: Placement;
+    vertical: boolean;
     gap: number;
     expandOnHover: boolean;
     showOverflow: boolean;

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

@@ -54,10 +54,10 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     size: "sm" | "md" | "lg";
     max: number;
     tone: "blue" | "green" | "purple" | "orange" | "gray" | "red";
-    checked: boolean;
-    placement: "top-right" | "top-left" | "bottom-right" | "bottom-left";
-    closeLabel: string;
     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>;

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

@@ -1,4 +1,5 @@
-import type { Component } from 'vue';
+import { type Component, type VNodeChild } from "vue";
+import type { HysPopupMotionProps } from "../../motion/popup";
 export interface HysBreadcrumbItem {
     label: string;
     href?: string;
@@ -7,46 +8,68 @@ export interface HysBreadcrumbItem {
     rel?: string;
     separator?: string;
     showSeparator?: boolean;
+    icon?: Component;
+    title?: string;
+    children?: readonly HysBreadcrumbItem[];
+    to?: unknown;
+    replace?: boolean;
 }
-type __VLS_Props = {
+export interface HysBreadcrumbSelectInfo {
+    index: number;
+    parent?: HysBreadcrumbItem;
+    path: readonly HysBreadcrumbItem[];
+    source: "dropdown" | "overflow";
+    event?: MouseEvent | KeyboardEvent;
+}
+export interface HysBreadcrumbProps extends HysPopupMotionProps {
+    items: readonly HysBreadcrumbItem[];
     separator?: string;
     separatorIcon?: Component;
-    items: HysBreadcrumbItem[];
     ariaLabel?: string;
+    size?: "sm" | "md" | "lg";
+    disabled?: boolean;
+    maxItems?: number;
+    itemsBeforeCollapse?: number;
+    itemsAfterCollapse?: number;
+    maxItemWidth?: number | string;
+    ellipsisLabel?: string;
+    dropdownLabel?: string;
+}
+type __VLS_Slots = {
+    item?: (scope: {
+        item: HysBreadcrumbItem;
+        index: number;
+        current: boolean;
+    }) => VNodeChild;
+    link?: (scope: {
+        item: HysBreadcrumbItem;
+        index: number;
+        current: boolean;
+        attrs: Record<string, unknown>;
+    }) => VNodeChild;
+    separator?: (scope: {
+        item: HysBreadcrumbItem;
+        index: number;
+    }) => VNodeChild;
+    overflow?: (scope: {
+        items: readonly HysBreadcrumbItem[];
+    }) => VNodeChild;
 };
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        separator?: (props: {
-            item: HysBreadcrumbItem;
-            index: number;
-        }) => any;
-    } & {
-        link?: (props: {
-            item: HysBreadcrumbItem;
-            index: number;
-        }) => any;
-    } & {
-        item?: (props: {
-            item: HysBreadcrumbItem;
-            index: number;
-            current: boolean;
-        }) => any;
-    } & {
-        item?: (props: {
-            item: HysBreadcrumbItem;
-            index: number;
-            current: 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, {
+declare const __VLS_base: import("vue").DefineComponent<HysBreadcrumbProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     select: (item: HysBreadcrumbItem, index: number, event: MouseEvent) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    dropdownSelect: (item: HysBreadcrumbItem, info: HysBreadcrumbSelectInfo) => any;
+}, string, import("vue").PublicProps, Readonly<HysBreadcrumbProps> & Readonly<{
     onSelect?: ((item: HysBreadcrumbItem, index: number, event: MouseEvent) => any) | undefined;
+    onDropdownSelect?: ((item: HysBreadcrumbItem, info: HysBreadcrumbSelectInfo) => any) | undefined;
 }>, {
+    size: "sm" | "md" | "lg";
     ariaLabel: string;
     separator: string;
+    maxItems: number;
+    itemsBeforeCollapse: number;
+    itemsAfterCollapse: number;
+    ellipsisLabel: string;
+    dropdownLabel: string;
 }, {}, {}, {}, 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/HysCalendar/HysCalendar.vue.d.ts

@@ -1,6 +1,7 @@
+import type { HysPopupMotionProps } from '../../motion/popup';
 import { type HysCalendarValue, type HysCalendarMode, type HysCalendarTransition, type HysCalendarAction, type HysCalendarSelectInfo, type HysCalendarCell, type HysCalendarMonthCell, type CalendarEvent } from "../../composables/calendar";
 declare const __VLS_export: <T extends HysCalendarValue = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(HysPopupMotionProps & {
         modelValue?: T;
         defaultValue?: T;
         valueType?: "string" | "date";
@@ -30,7 +31,7 @@ declare const __VLS_export: <T extends HysCalendarValue = string>(__VLS_props: N
         events?: readonly CalendarEvent[];
         maxEvents?: number;
         ariaLabel?: string;
-    } & {
+    }) & {
         onChange?: ((date: T) => any) | undefined;
         "onUpdate:modelValue"?: ((date: T) => any) | undefined;
         onSelect?: ((date: T, info: HysCalendarSelectInfo) => any) | undefined;

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

@@ -6,7 +6,7 @@ declare const __VLS_export: <V extends HysCascaderValue = string[], N extends ob
         "onUpdate:modelValue"?: ((value: V) => any) | undefined;
         onSearch?: ((value: string) => any) | undefined;
         onClear?: (() => any) | undefined;
-        onSelect?: ((path: import("../../index.js").HysTreeKey[], nodes: N[], event?: Event | undefined) => any) | undefined;
+        onSelect?: ((path: import("../..").HysTreeKey[], nodes: N[], event?: Event | undefined) => any) | undefined;
         onBlur?: ((event: FocusEvent) => any) | undefined;
         onFocus?: ((event: FocusEvent) => any) | undefined;
         onLoad?: ((info: {
@@ -38,10 +38,10 @@ declare const __VLS_export: <V extends HysCascaderValue = string[], N extends ob
             error: unknown;
         }) => any) | undefined;
         "onValue-change"?: ((value: V, info: HysCascaderChange<N>) => any) | undefined;
-        "onRemove-tag"?: ((path: import("../../index.js").HysTreeKey[], node?: N | undefined) => any) | undefined;
+        "onRemove-tag"?: ((path: import("../..").HysTreeKey[], node?: N | undefined) => any) | undefined;
         "onSearch-error"?: ((error: unknown, query: string) => any) | undefined;
-        "onUpdate:expandedPath"?: ((path: import("../../index.js").HysTreeKey[]) => any) | undefined;
-        onExpandChange?: ((path: import("../../index.js").HysTreeKey[], nodes: N[]) => any) | undefined;
+        "onUpdate:expandedPath"?: ((path: import("../..").HysTreeKey[]) => any) | undefined;
+        onExpandChange?: ((path: import("../..").HysTreeKey[], nodes: N[]) => any) | undefined;
         "onRoot-load"?: ((nodes: readonly N[]) => any) | undefined;
         "onRoot-load-error"?: ((error: unknown) => any) | undefined;
         "onVisible-change"?: ((value: boolean) => any) | undefined;
@@ -62,7 +62,7 @@ declare const __VLS_export: <V extends HysCascaderValue = string[], N extends ob
         filter: (text: string) => void;
         getSelectedItems: () => HysCascaderItem<N>[];
         getCheckedNodes: (leafOnly?: boolean) => N[];
-        getExpandedPath: () => import("../../index.js").HysTreeKey[];
+        getExpandedPath: () => import("../..").HysTreeKey[];
         setExpandedPath: (path: HysCascaderPath) => Promise<boolean>;
         reloadNode: (path: HysCascaderPath) => Promise<boolean>;
         reloadRoot: (force?: boolean) => Promise<boolean>;
@@ -102,7 +102,7 @@ declare const __VLS_export: <V extends HysCascaderValue = string[], N extends ob
             level: number;
         }) => any;
     };
-    emit: ((evt: "change", value: V, info: HysCascaderChange<N>) => void) & ((evt: "update:modelValue", value: V) => void) & ((evt: "search", value: string) => void) & ((evt: "clear") => void) & ((evt: "select", path: import("../../index.js").HysTreeKey[], nodes: N[], event?: Event | undefined) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "load", info: {
+    emit: ((evt: "change", value: V, info: HysCascaderChange<N>) => void) & ((evt: "update:modelValue", value: V) => void) & ((evt: "search", value: string) => void) & ((evt: "clear") => void) & ((evt: "select", path: import("../..").HysTreeKey[], nodes: N[], event?: Event | undefined) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "load", info: {
         node: N;
         path: HysCascaderKey[];
         children: N[];
@@ -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("../../index.js").HysTreeKey[], node?: N | undefined) => void) & ((evt: "search-error", error: unknown, query: string) => void) & ((evt: "update:expandedPath", path: import("../../index.js").HysTreeKey[]) => void) & ((evt: "expandChange", path: import("../../index.js").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: "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);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -25,8 +25,8 @@ declare const __VLS_export: <N extends object>(__VLS_props: NonNullable<Awaited<
         onScroll?: ((event: Event) => any) | undefined;
         onRetry?: ((entry: CascaderEntry<N>) => any) | undefined;
         onHover?: ((entry: CascaderEntry<N> | null) => any) | undefined;
-        onKeyboard?: ((event: KeyboardEvent, entry: CascaderEntry<N>, level: number) => 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: "keyboard", event: KeyboardEvent, entry: CascaderEntry<N>, level: number) => void) & ((evt: "choose", entry: CascaderEntry<N>, event?: Event | undefined, checked?: boolean | undefined) => void) & ((evt: "expand", entry: CascaderEntry<N>) => void);
+    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);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -0,0 +1,58 @@
+import type { useColorPicker } from "../../composables/useColorPicker";
+import { type HysColorPickerProps } from "../../composables/color";
+type __VLS_Props = {
+    state: ReturnType<typeof useColorPicker>;
+    options: HysColorPickerProps;
+};
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        header?: (props: {
+            value: string;
+            draft: string;
+            color: Readonly<import("../../index.js").HysColor>;
+            disabled: boolean;
+            readonly: boolean;
+            valid: boolean;
+            dirty: boolean;
+            setColor: (value: string) => Promise<boolean>;
+            confirm: () => Promise<boolean>;
+            cancel: () => void;
+            clear: () => Promise<boolean>;
+            show: () => Promise<boolean>;
+            hide: () => Promise<boolean>;
+        }) => any;
+    } & {
+        preset?: (props: {
+            value: string;
+            color: string;
+            selected: boolean;
+            disabled: boolean;
+        }) => any;
+    } & {
+        footer?: (props: {
+            value: string;
+            draft: string;
+            color: Readonly<import("../../index.js").HysColor>;
+            disabled: boolean;
+            readonly: boolean;
+            valid: boolean;
+            dirty: boolean;
+            setColor: (value: string) => Promise<boolean>;
+            confirm: () => Promise<boolean>;
+            cancel: () => void;
+            clear: () => Promise<boolean>;
+            show: () => Promise<boolean>;
+            hide: () => Promise<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, {}, 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/HysColorPicker/HysColorPicker.vue.d.ts

@@ -1,14 +1,67 @@
-type __VLS_Props = {
-    modelValue: string;
-    disabled?: boolean;
-    label?: string;
-    presets?: string[];
-    clearable?: boolean;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+import { type HysColorPickerProps, type HysColorPickerSlots } from "../../composables/color";
+type __VLS_Slots = HysColorPickerSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysColorPickerProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    input: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    panel: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    value: import("vue").ComputedRef<string>;
+    draft: import("vue").Ref<string, string>;
+    color: import("vue").ComputedRef<{
+        h: number;
+        s: number;
+        v: number;
+        a: number;
+    }>;
+    open: import("vue").ComputedRef<boolean>;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    show: () => Promise<boolean>;
+    hide: (restore?: boolean) => Promise<boolean>;
+    confirm: () => Promise<boolean>;
+    cancel: () => void;
+    clear: () => Promise<boolean>;
+    setColor: (raw: string) => Promise<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: string) => any;
     "update:modelValue": (value: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    clear: () => any;
+    visibleChange: (open: boolean) => any;
+    blur: (event: FocusEvent) => any;
+    cancel: () => any;
+    focus: (event: FocusEvent) => any;
+    invalid: (value: string) => any;
+    "update:open": (open: boolean) => any;
+    activeChange: (value: string) => any;
+    confirm: (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<HysColorPickerProps> & Readonly<{
+    onChange?: ((value: string) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    onClear?: (() => any) | undefined;
+    onVisibleChange?: ((open: boolean) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onInvalid?: ((value: string) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onActiveChange?: ((value: string) => any) | undefined;
+    onConfirm?: ((value: string) => any) | undefined;
+}>, {
+    modelValue: string;
+    immediate: boolean;
+    placement: import("../../index.js").Placement;
+    open: boolean;
+    popupWidth: string | number;
+    appendTo: string | false | HTMLElement;
+    showFooter: boolean;
+    validateEvent: boolean;
+    showInput: boolean;
+    showPresets: 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/HysCommandPalette/HysCommandPalette.vue.d.ts

@@ -1,9 +1,10 @@
+import type { HysPopupMotionProps } from '../../motion/popup';
 type Action = {
     id: string;
     label: string;
     description?: string;
 };
-type __VLS_Props = {
+type __VLS_Props = HysPopupMotionProps & {
     actions: Action[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

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

@@ -1,37 +1,53 @@
-type __VLS_Props = {
-    items: {
-        label: string;
-        value: string;
-        disabled?: boolean;
-        type?: 'item' | 'divider';
-    }[];
-    disabled?: boolean;
+import type { HysContextMenuItem, HysContextMenuProps, HysContextMenuSlots, HysMenuKey, HysMenuSelectInfo } from "../../composables/menu";
+declare const __VLS_export: <N extends object = HysContextMenuItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<HysContextMenuProps<N> & {
+        onSelect?: ((value: N extends {
+            value: infer V extends HysMenuKey;
+        } ? V : HysMenuKey, info: HysMenuSelectInfo<N>) => any) | undefined;
+        onVisibleChange?: ((value: boolean) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        "onUpdate:openPath"?: ((value: HysMenuKey[]) => any) | undefined;
+        onOpenPathChange?: ((value: HysMenuKey[]) => any) | undefined;
+        "onUpdate:checkedKeys"?: ((value: HysMenuKey[]) => any) | undefined;
+        onCheckedChange?: ((value: HysMenuKey[], info?: HysMenuSelectInfo<N> | undefined) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((value: HysMenuKey[]) => any) | undefined;
+        onSelectionChange?: ((value: HysMenuKey[], info?: HysMenuSelectInfo<N> | undefined) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        open: import("vue").Ref<boolean, boolean>;
+        checkedKeys: import("vue").ComputedRef<HysMenuKey[]>;
+        selectedKeys: import("vue").ComputedRef<HysMenuKey[]>;
+        openPath: import("vue").ComputedRef<HysMenuKey[]>;
+        focus: () => void;
+        blur: () => void;
+        show: (event?: MouseEvent | KeyboardEvent | import("../..").HysMenuShowOptions) => Promise<boolean>;
+        showAt: (x: number, y: number, focus?: boolean) => Promise<boolean>;
+        hide: (restore?: boolean) => Promise<boolean>;
+        handleOpen: () => Promise<boolean>;
+        handleClose: (restore?: boolean) => Promise<boolean>;
+        toggle: () => Promise<boolean>;
+        focusItem: (key: HysMenuKey) => Promise<boolean>;
+        openSubmenu: (key: HysMenuKey, focusChild?: boolean) => Promise<boolean>;
+        closeSubmenus: () => Promise<boolean>;
+        setCheckedKeys: (keys: readonly HysMenuKey[]) => Promise<boolean>;
+        setSelectedKeys: (keys: readonly HysMenuKey[]) => Promise<boolean>;
+        getItems: () => N[];
+    }>) => void;
+    attrs: any;
+    slots: HysContextMenuSlots<N>;
+    emit: ((evt: "select", value: N extends {
+        value: infer V extends HysMenuKey;
+    } ? V : HysMenuKey, info: HysMenuSelectInfo<N>) => void) & ((evt: "visibleChange", value: boolean) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:openPath", value: HysMenuKey[]) => void) & ((evt: "openPathChange", value: HysMenuKey[]) => void) & ((evt: "update:checkedKeys", value: HysMenuKey[]) => void) & ((evt: "checkedChange", value: HysMenuKey[], info?: HysMenuSelectInfo<N> | undefined) => void) & ((evt: "update:selectedKeys", value: HysMenuKey[]) => void) & ((evt: "selectionChange", value: HysMenuKey[], info?: HysMenuSelectInfo<N> | undefined) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        default?: (props: {}) => any;
-    } & {
-        item?: (props: {
-            item: {
-                label: string;
-                value: string;
-                disabled?: boolean;
-                type?: "item" | "divider";
-            };
-        }) => 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, {
-    select: (value: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onSelect?: ((value: string) => any) | undefined;
-}>, {}, {}, {}, {}, 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;
-    };
-};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};