hys-ui 0.4.0 → 0.6.0

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

@@ -0,0 +1,121 @@
+import type { HysToastApi, HysToastCloseContext, HysToastConfig, HysToastType } from "../components/HysToast/toastTypes";
+import { type ToastEntry, type ToastInstance } from "./toastQueueModel";
+export declare function createToastQueue(config: HysToastConfig, host: {
+    mount: () => void;
+    empty: () => void;
+}, reportError: (error: unknown) => void): {
+    api: HysToastApi;
+    records: import("vue").ShallowReactive<Map<string, ToastEntry>>;
+    settings: import("vue").ShallowRef<{
+        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;
+        progress?: import("./useHysToast").HysToastProgress | undefined;
+        type?: HysToastType | undefined;
+        width?: string | number | undefined;
+        direction?: import("./useHysToast").HysToastDirection | undefined;
+        offset?: number | undefined;
+        duration?: number | undefined;
+        animation?: (import("./useHysToast").HysToastAnimation | import("./useHysToast").HysToastMotionPreset) | undefined;
+        closable?: boolean | undefined;
+        showIcon?: boolean | undefined;
+        beforeClose?: ((context: HysToastCloseContext) => boolean | void | Promise<boolean | void>) | undefined;
+        easing?: string | ((progress: number) => number) | undefined;
+        plain?: boolean | undefined;
+        locale?: Partial<import("./useHysToast").HysToastLocale> | undefined;
+        position?: import("./useHysToast").HysToastPosition | undefined;
+        animationDuration?: number | undefined;
+        zIndex?: number | undefined;
+        maxLines?: number | undefined;
+        actions?: readonly import("./useHysToast").HysToastAction[] | undefined;
+        closeOnEscape?: boolean | undefined;
+        live?: "polite" | "assertive" | "off" | undefined;
+        swipe?: boolean | undefined;
+        persistent?: boolean | undefined;
+        closeOnClick?: boolean | undefined;
+        keyboardDismiss?: boolean | undefined;
+        pauseOnHover?: boolean | undefined;
+        pauseOnBlur?: boolean | undefined;
+        interactive?: boolean | undefined;
+        offsetX?: number | undefined;
+        offsetY?: number | undefined;
+        coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
+        glass?: boolean | undefined;
+        toastStyle?: import("vue").CSSProperties | undefined;
+        progressStyle?: import("vue").CSSProperties | undefined;
+        showProgress?: boolean | undefined;
+        countdown?: boolean | undefined;
+        copyable?: boolean | undefined;
+        actionLayout?: "inline" | "footer" | undefined;
+    }, {
+        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;
+        progress?: import("./useHysToast").HysToastProgress | undefined;
+        type?: HysToastType | undefined;
+        width?: string | number | undefined;
+        direction?: import("./useHysToast").HysToastDirection | undefined;
+        offset?: number | undefined;
+        duration?: number | undefined;
+        animation?: (import("./useHysToast").HysToastAnimation | import("./useHysToast").HysToastMotionPreset) | undefined;
+        closable?: boolean | undefined;
+        showIcon?: boolean | undefined;
+        beforeClose?: ((context: HysToastCloseContext) => boolean | void | Promise<boolean | void>) | undefined;
+        easing?: string | ((progress: number) => number) | undefined;
+        plain?: boolean | undefined;
+        locale?: Partial<import("./useHysToast").HysToastLocale> | undefined;
+        position?: import("./useHysToast").HysToastPosition | undefined;
+        animationDuration?: number | undefined;
+        zIndex?: number | undefined;
+        maxLines?: number | undefined;
+        actions?: readonly import("./useHysToast").HysToastAction[] | undefined;
+        closeOnEscape?: boolean | undefined;
+        live?: "polite" | "assertive" | "off" | undefined;
+        swipe?: boolean | undefined;
+        persistent?: boolean | undefined;
+        closeOnClick?: boolean | undefined;
+        keyboardDismiss?: boolean | undefined;
+        pauseOnHover?: boolean | undefined;
+        pauseOnBlur?: boolean | undefined;
+        interactive?: boolean | undefined;
+        offsetX?: number | undefined;
+        offsetY?: number | undefined;
+        coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
+        glass?: boolean | undefined;
+        toastStyle?: import("vue").CSSProperties | undefined;
+        progressStyle?: import("vue").CSSProperties | undefined;
+        showProgress?: boolean | undefined;
+        countdown?: boolean | undefined;
+        copyable?: boolean | undefined;
+        actionLayout?: "inline" | "footer" | undefined;
+    }>;
+    order: (a: ToastEntry, b: ToastEntry) => number;
+    notify: <T extends unknown[]>(callback: ((...args: T) => void) | undefined, ...args: T) => void;
+    begin: (entry: ToastEntry, closeContext: HysToastCloseContext) => void;
+    finish: (entry: ToastEntry) => void;
+    setInstance: (entry: ToastEntry, instance: ToastInstance | null, stack: string) => void;
+    suspend: (permanent?: boolean) => void;
+    resume: () => void;
+};

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

@@ -0,0 +1,116 @@
+import type { ToastClock } from "../components/HysToast/useToastTimer";
+import type { HysToastCloseContext, HysToastCloseReason, HysToastConfig, HysToastContext, HysToastFilter, HysToastHandle, HysToastOptions, HysToastSnapshot, HysToastStatus } from "../components/HysToast/toastTypes";
+export interface ToastInstance {
+    close(reason?: HysToastCloseReason, event?: Event, force?: boolean): Promise<boolean>;
+    restart(): void;
+    extend(milliseconds: number): void;
+    snapshotClock(): ToastClock;
+    restoreClock(clock: ToastClock): void;
+}
+export interface ToastEntry {
+    id: string;
+    serial: number;
+    options: HysToastOptions;
+    status: HysToastStatus;
+    repeat: number;
+    lastSeen: number;
+    paused: boolean;
+    extending: number;
+    clock?: ToastClock;
+    shown?: boolean;
+    entered?: boolean;
+    closeContext?: HysToastCloseContext;
+    handle: HysToastHandle;
+    resolve: () => void;
+}
+export declare const nextToastSequence: () => number;
+export declare const asOptions: (value: string | HysToastOptions) => HysToastOptions;
+export declare function presentation(options: HysToastOptions): {
+    message?: string;
+    title?: string;
+    type?: import("./useHysToast").HysToastType;
+    duration?: number;
+    persistent?: boolean;
+    closable?: boolean;
+    closeOnClick?: boolean;
+    closeOnEscape?: boolean;
+    keyboardDismiss?: boolean;
+    pauseOnHover?: boolean;
+    pauseOnBlur?: boolean;
+    swipe?: boolean;
+    interactive?: boolean;
+    position?: import("./useHysToast").HysToastPosition;
+    offset?: number;
+    offsetX?: number;
+    offsetY?: number;
+    coordinates?: import("./useHysToast").HysToastCoordinates;
+    zIndex?: number;
+    width?: string | number;
+    showIcon?: boolean;
+    plain?: boolean;
+    glass?: boolean;
+    theme?: import("..").HysTheme;
+    toastStyle?: import("vue").CSSProperties;
+    progressStyle?: import("vue").CSSProperties;
+    progress?: import("./useHysToast").HysToastProgress;
+    showProgress?: boolean;
+    countdown?: boolean;
+    maxLines?: number;
+    copyable?: boolean;
+    copyText?: string;
+    actionLayout?: "inline" | "footer";
+    actions?: readonly import("./useHysToast").HysToastAction[];
+    animation?: import("./useHysToast").HysToastAnimation | import("./useHysToast").HysToastMotionPreset;
+    direction?: import("./useHysToast").HysToastDirection;
+    animationDuration?: number;
+    easing?: string | ((progress: number) => number);
+    live?: "polite" | "assertive" | "off";
+    locale?: Partial<import("./useHysToast").HysToastLocale>;
+    beforeClose?: (context: HysToastCloseContext) => boolean | void | Promise<boolean | void>;
+};
+export declare function toastStackKey(options: HysToastOptions): string;
+export declare function defaults(config: HysToastConfig): {
+    grouping?: boolean;
+    dedupe?: "ignore" | "merge";
+    dedupeWindow?: number;
+    progress?: import("./useHysToast").HysToastProgress | undefined;
+    type?: import("./useHysToast").HysToastType | undefined;
+    width?: string | number | undefined;
+    direction?: import("./useHysToast").HysToastDirection | undefined;
+    offset?: number | undefined;
+    duration?: number | undefined;
+    animation?: (import("./useHysToast").HysToastAnimation | import("./useHysToast").HysToastMotionPreset) | undefined;
+    closable?: boolean | undefined;
+    showIcon?: boolean | undefined;
+    beforeClose?: ((context: HysToastCloseContext) => boolean | void | Promise<boolean | void>) | undefined;
+    easing?: string | ((progress: number) => number) | undefined;
+    plain?: boolean | undefined;
+    locale?: Partial<import("./useHysToast").HysToastLocale> | undefined;
+    position?: import("./useHysToast").HysToastPosition | undefined;
+    animationDuration?: number | undefined;
+    zIndex?: number | undefined;
+    maxLines?: number | undefined;
+    actions?: readonly import("./useHysToast").HysToastAction[] | undefined;
+    closeOnEscape?: boolean | undefined;
+    live?: "polite" | "assertive" | "off" | undefined;
+    swipe?: boolean | undefined;
+    persistent?: boolean | undefined;
+    closeOnClick?: boolean | undefined;
+    keyboardDismiss?: boolean | undefined;
+    pauseOnHover?: boolean | undefined;
+    pauseOnBlur?: boolean | undefined;
+    interactive?: boolean | undefined;
+    offsetX?: number | undefined;
+    offsetY?: number | undefined;
+    coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
+    glass?: boolean | undefined;
+    toastStyle?: import("vue").CSSProperties | undefined;
+    progressStyle?: import("vue").CSSProperties | undefined;
+    showProgress?: boolean | undefined;
+    countdown?: boolean | undefined;
+    copyable?: boolean | undefined;
+    actionLayout?: "inline" | "footer" | undefined;
+};
+export declare function context(entry: ToastEntry): HysToastContext;
+export declare function snapshot(entry: ToastEntry): HysToastSnapshot;
+export declare function matches(entry: ToastEntry, filter?: HysToastFilter): boolean;

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

@@ -0,0 +1,2 @@
+import type { HysToastApi } from "../components/HysToast/toastTypes";
+export declare function createToastTaskRunner(show: HysToastApi["show"], reportError: (error: unknown) => void): HysToastApi["promise"];

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

@@ -0,0 +1,37 @@
+import { type MaybeRefOrGetter } from "vue";
+import type { HysNumberComposableOptions, HysNumberEvent, HysNumberFrame, HysNumberValue } from "./animatedNumber";
+/** 在 Vue setup 中使用。与 HysAnimatedNumber 共享调度和播放控制。 */
+export declare function useHysAnimatedNumber(source?: MaybeRefOrGetter<HysNumberComposableOptions>, onEvent?: (event: HysNumberEvent, frame: HysNumberFrame) => void): {
+    frame: Readonly<import("vue").Ref<{
+        readonly value: HysNumberValue;
+        readonly from: HysNumberValue;
+        readonly to: HysNumberValue;
+        readonly progress: number;
+        readonly easedProgress: number;
+        readonly direction: import("./animatedNumber").HysNumberDirection;
+        readonly status: import("./animatedNumber").HysNumberStatus;
+        readonly iteration: number;
+    }, {
+        readonly value: HysNumberValue;
+        readonly from: HysNumberValue;
+        readonly to: HysNumberValue;
+        readonly progress: number;
+        readonly easedProgress: number;
+        readonly direction: import("./animatedNumber").HysNumberDirection;
+        readonly status: import("./animatedNumber").HysNumberStatus;
+        readonly iteration: number;
+    }>>;
+    motionEnabled: import("vue").ComputedRef<boolean>;
+    play: () => void;
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+    restart: () => void;
+    reset: () => void;
+    reverse: () => void;
+    seek: (progress: number) => void;
+    finishAnimation: () => void;
+    updateTarget: (next: HysNumberValue) => void;
+    sync: () => void;
+    hold: (value: boolean) => void;
+};

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

@@ -0,0 +1,4 @@
+import { type MaybeRefOrGetter } from "vue";
+import type { HysNumberControls } from "./animatedNumber";
+/** 同时控制组件实例和独立动画。空实例会被跳过。 */
+export declare function useHysNumberAnimationGroup(source: MaybeRefOrGetter<readonly (HysNumberControls | null | undefined)[]>): HysNumberControls;

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

@@ -1,50 +1,6 @@
-import { type VNodeChild } from 'vue';
-import type { HysToastPosition, HysToastType } from '../components/HysToast/HysToast.vue';
-import { type HysConfig } from '../config';
-export interface HysToastOptions {
-    id?: string;
-    message?: string;
-    content?: VNodeChild | (() => VNodeChild);
-    type?: HysToastType;
-    duration?: number;
-    closable?: boolean;
-    position?: HysToastPosition;
-    offset?: number;
-    zIndex?: number;
-    showIcon?: boolean;
-    icon?: VNodeChild | (() => VNodeChild);
-    plain?: boolean;
-    pauseOnHover?: boolean;
-    closeOnEscape?: boolean;
-    grouping?: boolean;
-    onClose?: () => void;
-    onAfterClose?: () => void;
-}
-export interface HysToastConfig extends Omit<HysToastOptions, 'id' | 'message' | 'content' | 'icon' | 'onClose' | 'onAfterClose'> {
-    maxCount?: number;
-    appendTo?: string | HTMLElement | ShadowRoot;
-}
-export interface HysToastHandle {
-    readonly id: string;
-    readonly closed: Promise<void>;
-    close(): void;
-    update(value: string | Omit<Partial<HysToastOptions>, 'id'>): void;
-}
-export interface HysToastApi {
-    show(value: string | HysToastOptions): HysToastHandle;
-    success(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    info(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    warning(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    error(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    loading(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
-    closeAll(): void;
-}
-export interface HysToastServiceConfig extends HysToastConfig, HysConfig {
-}
-export interface HysToastService extends HysToastApi {
-    dispose(): void;
-}
-/** Call during setup. Messages inherit the owner's theme and are removed when its scope leaves. */
+import type { HysToastApi, HysToastConfig, HysToastService, HysToastServiceConfig } from "../components/HysToast/toastTypes";
+export type * from "../components/HysToast/toastTypes";
 export declare function useHysToast(config?: HysToastConfig): HysToastApi;
-/** Create a shared service for callers outside setup; dispose it when the owning application ends. */
 export declare function createHysToast(config?: HysToastServiceConfig): HysToastService;
+export declare function configureHysToast(config: HysToastServiceConfig): void;
+export declare const hysToast: HysToastService;

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

@@ -1,6 +1,26 @@
 import { type CSSProperties, type HTMLAttributes } from "vue";
 import type { HysPopupSurfaceContext, HysPopupSurfaceProps } from "./popupSurface";
 export declare function usePopupSurface(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", emit: (name: string, ...args: any[]) => void): {
+    afterEnter: () => Promise<void>;
+    afterLeave: () => Promise<void>;
+    inactive: () => void;
+    request: (value: boolean, restore?: boolean) => Promise<boolean>;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    updatePosition: () => void;
+    focus: () => void | undefined;
+    pointerEnter: () => void;
+    pointerLeave: () => void;
+    panelEnter: () => void;
+    panelLeave: () => void;
+    focusIn: (event: FocusEvent) => void;
+    focusOut: (event: FocusEvent) => void;
+    panelFocusIn: () => void;
+    panelFocusOut: (event: FocusEvent) => void;
+    click: (event: MouseEvent) => void;
+    contextmenu: (event: MouseEvent) => void;
+    key: (event: KeyboardEvent) => void;
     wrapper: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
     referenceElement: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
     panel: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
@@ -3318,24 +3338,4 @@ export declare function usePopupSurface(props: HysPopupSurfaceProps, kind: "tool
     contentStyle: import("vue").ComputedRef<CSSProperties>;
     scope: import("vue").ComputedRef<HysPopupSurfaceContext>;
     wrapperAttrs: import("vue").ComputedRef<HTMLAttributes>;
-    pointerEnter: () => void;
-    pointerLeave: () => void;
-    panelEnter: () => void;
-    panelLeave: () => void;
-    focusIn: (event: FocusEvent) => void;
-    focusOut: (event: FocusEvent) => void;
-    panelFocusIn: () => void;
-    panelFocusOut: (event: FocusEvent) => void;
-    click: (event: MouseEvent) => void;
-    contextmenu: (event: MouseEvent) => void;
-    key: (event: KeyboardEvent) => void;
-    afterEnter: () => Promise<void>;
-    afterLeave: () => Promise<void>;
-    inactive: () => void;
-    request: (value: boolean, restore?: boolean) => Promise<boolean>;
-    show: () => Promise<boolean>;
-    hide: () => Promise<boolean>;
-    toggle: () => Promise<boolean>;
-    updatePosition: () => void;
-    focus: () => void | undefined;
 };

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

@@ -0,0 +1,33 @@
+import { type Ref } from "vue";
+import type { HysPopupSurfaceProps } from "./popupSurface";
+import type { FloatingAnchor, useFloating } from "./useFloating";
+export declare const popupFocusControls = "button,a[href],input,select,textarea,[tabindex]:not([tabindex=\"-1\"]),[contenteditable=\"true\"]";
+export declare function usePopupSurfaceInteractions(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", { available, anchor, actualReference, panel, floating, restoreReferenceFocus, request, }: {
+    available: Readonly<Ref<boolean>>;
+    anchor: Readonly<Ref<FloatingAnchor | undefined>>;
+    actualReference: Readonly<Ref<HTMLElement | undefined>>;
+    panel: Readonly<Ref<HTMLElement | undefined>>;
+    floating: Pick<ReturnType<typeof useFloating>, "open" | "isTop" | "restoringFocus">;
+    restoreReferenceFocus: () => void;
+    request: (open: boolean) => Promise<boolean>;
+}): {
+    clearDelays: () => void;
+    clearAuto: () => void;
+    resetReasons: () => void;
+    reset: () => void;
+    startAuto: () => void;
+    tab: (event: KeyboardEvent) => Promise<void>;
+    handlers: {
+        pointerEnter: () => void;
+        pointerLeave: () => void;
+        panelEnter: () => void;
+        panelLeave: () => void;
+        focusIn: (event: FocusEvent) => void;
+        focusOut: (event: FocusEvent) => void;
+        panelFocusIn: () => void;
+        panelFocusOut: (event: FocusEvent) => void;
+        click: (event: MouseEvent) => void;
+        contextmenu: (event: MouseEvent) => void;
+        key: (event: KeyboardEvent) => void;
+    };
+};

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

@@ -1,3 +1,6 @@
 import { type Ref } from "vue";
-import type { HysInputProps } from "./textInput";
-export declare function useTextareaSize(input: Ref<HTMLInputElement | HTMLTextAreaElement | undefined>, props: HysInputProps, size: Ref<string>, value: Ref<string>): () => Promise<void>;
+import type { HysInputProps, HysTextareaStyle } from "./textInput";
+export declare function useTextareaSize(input: Ref<HTMLInputElement | HTMLTextAreaElement | undefined>, props: HysInputProps, size: Ref<string>, value: Ref<string>): {
+    resize: () => Promise<void>;
+    textareaStyle: import("vue").ShallowRef<HysTextareaStyle, HysTextareaStyle>;
+};

package/dist/types/index.d.ts

@@ -4,8 +4,6 @@ export type { HysAccordionKey } from './components/HysAccordion/HysAccordion.vue
 export type { HysAccordionItem } from './components/HysAccordion/HysAccordion.vue';
 export { default as HysAlert } from './components/HysAlert/HysAlert.vue';
 export { default as HysAnimatedNumber } from './components/HysAnimatedNumber/HysAnimatedNumber.vue';
-export type { HysAnimatedNumberContext } from './components/HysAnimatedNumber/HysAnimatedNumber.vue';
-export type { HysAnimatedNumberProps } from './components/HysAnimatedNumber/HysAnimatedNumber.vue';
 export { default as HysAutocomplete } from './components/HysAutocomplete/HysAutocomplete.vue';
 export { default as HysAvatar } from './components/HysAvatar/HysAvatar.vue';
 export { default as HysAvatarGroup } from './components/HysAvatarGroup/HysAvatarGroup.vue';
@@ -111,8 +109,6 @@ export { default as HysTagInput } from './components/HysTagInput/HysTagInput.vue
 export { default as HysTextarea } from './components/HysTextarea/HysTextarea.vue';
 export { default as HysTimeline } from './components/HysTimeline/HysTimeline.vue';
 export { default as HysToast } from './components/HysToast/HysToast.vue';
-export type { HysToastType } from './components/HysToast/HysToast.vue';
-export type { HysToastPosition } from './components/HysToast/HysToast.vue';
 export { default as HysTooltip } from './components/HysTooltip/HysTooltip.vue';
 export { default as HysTour } from './components/HysTour/HysTour.vue';
 export { default as HysTransfer } from './components/HysTransfer/HysTransfer.vue';
@@ -129,9 +125,11 @@ export type { HysFormCol, HysFormColSize, HysFormGridValue, HysFormBreakpoint }
 export type { HysSelectValue, HysSelectModelValue, HysSelectOption, HysSelectGroup, HysSelectDataOption, HysSelectFieldNames, HysSelectSearchContext, HysSelectInstance } from './composables/selectOptions';
 export type { HysNumberInputValue, HysNumberInputFormatInfo, HysNumberInputStepInfo, HysNumberInputInvalidInfo, HysNumberInputInstance } from './composables/numberInput';
 export type { HysInputProps, HysTextareaProps, HysInputFormatInfo, HysInputCountInfo, HysInputCountStrategy, HysInputInstance, HysTextareaInstance } from './composables/textInput';
-export { useHysToast, createHysToast } from './composables/useHysToast';
-export type { HysToastApi, HysToastOptions, HysToastConfig, HysToastHandle, HysToastServiceConfig, HysToastService } from './composables/useHysToast';
+export { useHysToast, createHysToast, hysToast, configureHysToast } from './composables/useHysToast';
+export type { HysToastApi, HysToastOptions, HysToastConfig, HysToastHandle, HysToastServiceConfig, HysToastService, HysToastType, HysToastPosition, HysToastProps, HysToastPresentation, HysToastCloseReason, HysToastCloseContext, HysToastContext, HysToastAction, HysToastActionContext, HysToastActionEvent, HysToastAnimation, HysToastDirection, HysToastMotionPreset, HysToastLocale, HysToastCoordinates, HysToastProgress, HysToastStatus, HysToastSnapshot, HysToastFilter, HysToastPatch, HysToastRender, HysToastFeedback, HysToastTaskContext, HysToastPromiseOptions, HysToastTask } from './composables/useHysToast';
 export type { HysSliderValue, HysSliderStep, HysSliderMarks, HysSliderDragInfo, HysSliderInstance } from './composables/slider';
+export type { HysInputSize, HysInputModelModifiers, HysTextareaStyle } from './composables/textInput';
+export type { HysSortKey, HysSortItem, HysSortLayout, HysSortMode, HysSortOperation, HysSortPosition, HysSortSource, HysSortFixed, HysSortDecision, HysSortReason, HysSortListInfo, HysSortDrag, HysSortProposal, HysSortListChange, HysSortPreview, HysSortChange, HysSortFeedback, HysSortGroup, HysSortScroll, HysSortVirtual, HysSortRow, HysSortableListProps, HysSortMoveOptions, HysSortableListInstance } from './components/HysSortableList/sortableList';
 export type { HysSelectLabeledValue } from './composables/selectOptions';
 export type { HysAvatarProps, HysAvatarSize, HysAvatarBreakpoint, HysAvatarFit, HysAvatarLoadInfo, HysAvatarOption, HysAvatarInstance, HysAvatarGroupProps, HysAvatarGroupInstance } from './composables/avatar';
 export type { HysAutocompleteProps, HysAutocompleteRow, HysAutocompleteOption, HysAutocompleteItem, HysAutocompleteGroup, HysAutocompleteDataOption, HysAutocompleteContext, HysAutocompleteCallback, HysAutocompleteFetch, HysAutocompleteInstance } from './composables/autocomplete';
@@ -162,6 +160,17 @@ export type { HysDrawerProps, HysDrawerBeforeClose, HysDrawerPlacement, HysDrawe
 export type { HysPopupPlacement, HysPopupTrigger, HysPopupVirtualReference, HysPopupReference, HysPopupSurfaceProps, HysTooltipProps, HysPopoverProps, HysPopupSurfaceContext, HysTooltipSlots, HysPopoverSlots, HysPopupSurfaceInstance, HysTooltipInstance, HysPopoverInstance } from './composables/popupSurface';
 export type { HysUploadFile, HysUploadItem, HysUploadStatus, HysUploadListType, HysUploadChangeType, HysUploadChange, HysUploadContext, HysUploadInvalid, HysUploadError, HysUploadDataScalar, HysUploadData, HysUploadRequestOptions, HysUploadRequestResult, HysUploadLocale, HysUploadProps, HysUploadActions, HysUploadFileContext, HysUploadSlotContext, HysUploadSlots, HysUploadInstance } from './composables/upload';
 export type { HysProgressType, HysProgressStatus, HysProgressSize, HysProgressLinecap, HysProgressGapPosition, HysProgressGradientDirection, HysProgressGradientStop, HysProgressGradient, HysProgressColorStop, HysProgressColor, HysProgressSuccess, HysProgressLabelContext, HysProgressProps, HysProgressSlots, HysProgressInstance } from './composables/progress';
+export { useHysAnimatedNumber } from './composables/useHysAnimatedNumber';
+export { useHysNumberAnimationGroup } from './composables/useHysNumberAnimationGroup';
+export { hysNumberAnimationCatalog, hysNumberAnimationCategories } from './composables/numberAnimationCatalog';
+export type { HysNumberAnimationCategory, HysNumberAnimationName, HysNumberAnimationEntry } from './composables/numberAnimationCatalog';
+export { parseHysNumberAnimation, stringifyHysNumberAnimation } from './composables/numberAnimation';
+export type { HysNumberAnimation, HysNumberAnimationConfig, HysNumberAnimationItem, HysNumberAnimationPresets, HysNumberDigitAnimations } from './composables/numberAnimation';
+export { createHysNumberSequence } from './composables/numberAnimationSequence';
+export type { HysNumberSequenceStep } from './composables/numberAnimationSequence';
+export type { HysNumberInterpolationContext } from './composables/animatedNumber';
+export type { HysNumberComposableOptions } from './composables/animatedNumber';
+export type { HysAnimatedNumberContext, HysAnimatedNumberProps, HysAnimatedNumberInstance, HysNumberValue, HysNumberDirection, HysNumberStatus, HysNumberEasing, HysNumberInterrupt, HysNumberTrigger, HysNumberEffect, HysNumberRounding, HysNumberFormat, HysNumberAnimationOptions, HysNumberFrame, HysNumberTrend, HysNumberEvent, HysNumberControls, HysNumberUnitRule, HysNumberFormatOptions, HysNumberDigitContext } from './composables/animatedNumber';
 export type { HysAlertTone, HysAlertEffect, HysAlertTransition, HysAlertCloseContext, HysAlertProps, HysAlertSlotContext, HysAlertSlots, HysAlertInstance, HysEmptyIllustration, HysEmptyProps, HysEmptySlotContext, HysEmptySlots, HysEmptyInstance } from './composables/feedback';
 export type { HysTimelineKey, HysTimelineMode, HysTimelinePosition, HysTimelineSize, HysTimelineTone, HysTimelineItem, HysTimelineFieldNames, HysTimelineProps, HysTimelineItemContext, HysTimelinePendingContext, HysTimelineSlots, HysTimelineInstance } from './composables/timeline';
 export type { HysTagInputReason, HysTagInputAddContext, HysTagInputInvalid, HysTagInputProps, HysTagInputSlotContext, HysTagInputTagContext, HysTagInputSlots, HysTagInputInstance } from './composables/tagInput';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hys-ui",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Themeable Vue 3 components with TypeScript and interactive documentation",
   "type": "module",
   "license": "MIT",