hys-ui 0.5.0 → 0.6.0

package/dist/types/components/HysToast/toastPresentation.d.ts

@@ -0,0 +1,8 @@
+import type { CSSProperties } from "vue";
+import type { HysToastLocale, HysToastPosition, HysToastPresentation } from "./toastTypes";
+export declare const toastLocale: HysToastLocale;
+export declare function normalizeToastPosition(position?: HysToastPosition): "center" | "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center" | "custom";
+export declare const finite: (value: number | undefined, fallback: number) => number;
+export declare const toastDuration: (options: HysToastPresentation) => number;
+export declare function toastPlacement(options: HysToastPresentation): CSSProperties;
+export declare function toastMotion(options: HysToastPresentation): CSSProperties;

package/dist/types/components/HysToast/toastTypes.d.ts

@@ -0,0 +1,212 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import type { HysConfig, HysTheme } from "../../config";
+export type HysToastType = "success" | "error" | "warning" | "info" | "loading" | "default" | "custom";
+export type HysToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right" | "center" | "custom" | "top" | "bottom";
+export type HysToastCloseReason = "timeout" | "button" | "click" | "escape" | "keyboard" | "swipe" | "action" | "api" | "model" | "overflow" | "dispose";
+export type HysToastStatus = "queued" | "visible" | "closing" | "closed";
+export type HysToastAnimation = "fade" | "slide" | "scale" | "spring" | "bounce" | "rotate" | "none";
+export type HysToastDirection = "top" | "bottom" | "left" | "right";
+export type HysToastProgress = number | "indeterminate";
+export type HysToastCoordinates = Pick<CSSProperties, "top" | "right" | "bottom" | "left" | "translate">;
+export interface HysToastMotionPreset {
+    enterFrom: string;
+    leaveTo?: string;
+    opacity?: number;
+}
+export interface HysToastLocale {
+    close: string;
+    copy: string;
+    copied: string;
+    copyFailed: string;
+    expand: string;
+    collapse: string;
+    collapseStack: string;
+    pinStack: string;
+    remaining: (seconds: number) => string;
+    repeat: (count: number) => string;
+    more: (count: number) => string;
+    actionFailed: string;
+    progress: string;
+}
+export interface HysToastPresentation {
+    message?: string;
+    title?: string;
+    type?: HysToastType;
+    duration?: number;
+    persistent?: boolean;
+    closable?: boolean;
+    closeOnClick?: boolean;
+    closeOnEscape?: boolean;
+    keyboardDismiss?: boolean;
+    pauseOnHover?: boolean;
+    pauseOnBlur?: boolean;
+    swipe?: boolean;
+    interactive?: boolean;
+    position?: HysToastPosition;
+    offset?: number;
+    offsetX?: number;
+    offsetY?: number;
+    coordinates?: HysToastCoordinates;
+    zIndex?: number;
+    width?: string | number;
+    showIcon?: boolean;
+    plain?: boolean;
+    glass?: boolean;
+    theme?: HysTheme;
+    toastStyle?: CSSProperties;
+    progressStyle?: CSSProperties;
+    progress?: HysToastProgress;
+    showProgress?: boolean;
+    countdown?: boolean;
+    maxLines?: number;
+    copyable?: boolean;
+    copyText?: string;
+    actionLayout?: "inline" | "footer";
+    actions?: readonly HysToastAction[];
+    animation?: HysToastAnimation | HysToastMotionPreset;
+    direction?: HysToastDirection;
+    animationDuration?: number;
+    easing?: string | ((progress: number) => number);
+    live?: "polite" | "assertive" | "off";
+    locale?: Partial<HysToastLocale>;
+    beforeClose?: (context: HysToastCloseContext) => boolean | void | Promise<boolean | void>;
+}
+export interface HysToastProps extends HysToastPresentation {
+    open?: boolean;
+    teleport?: boolean;
+    appendTo?: string | HTMLElement | ShadowRoot;
+    repeat?: number;
+    paused?: boolean;
+}
+export interface HysToastContext {
+    id?: string;
+    message: string;
+    title?: string;
+    type: HysToastType;
+}
+export interface HysToastCloseContext extends HysToastContext {
+    reason: HysToastCloseReason;
+    event?: Event;
+}
+export interface HysToastActionContext extends HysToastContext {
+    close: () => Promise<boolean>;
+    update: (patch: HysToastPatch) => void;
+    copy: () => Promise<boolean>;
+}
+export interface HysToastAction {
+    id: string;
+    label: string;
+    disabled?: boolean;
+    closeOnSuccess?: boolean;
+    run?: (context: HysToastActionContext) => unknown;
+    success?: HysToastFeedback<unknown>;
+    error?: HysToastFeedback<unknown>;
+}
+export interface HysToastActionEvent extends HysToastContext {
+    action: HysToastAction;
+    status: "start" | "success" | "error";
+    result?: unknown;
+}
+export type HysToastRender = VNodeChild | ((context: HysToastActionContext) => VNodeChild);
+export interface HysToastOptions extends HysToastPresentation {
+    id?: string;
+    content?: HysToastRender;
+    icon?: HysToastRender;
+    header?: HysToastRender;
+    footer?: HysToastRender;
+    renderActions?: HysToastRender;
+    priority?: number;
+    group?: string;
+    grouping?: boolean;
+    dedupe?: "ignore" | "merge";
+    dedupeKey?: string;
+    dedupeWindow?: number;
+    onShow?: (context: HysToastContext) => void;
+    onAfterShow?: (context: HysToastContext) => void;
+    onClose?: (context: HysToastCloseContext) => void;
+    onAfterClose?: (context: HysToastCloseContext) => void;
+    onClick?: (event: MouseEvent, context: HysToastContext) => void;
+    onAction?: (event: HysToastActionEvent) => void;
+    onStateChange?: (snapshot: HysToastSnapshot) => void;
+}
+export type HysToastPatch = string | Partial<Omit<HysToastOptions, "id">>;
+export type HysToastFeedback<T> = HysToastPatch | ((value: T) => HysToastPatch);
+export type HysToastFilter = {
+    type?: HysToastType;
+    group?: string;
+    position?: HysToastPosition;
+    status?: HysToastStatus;
+};
+export interface HysToastSnapshot extends HysToastContext {
+    id: string;
+    status: HysToastStatus;
+    position: HysToastPosition;
+    group?: string;
+    priority: number;
+    repeat: number;
+}
+export interface HysToastConfig extends Omit<HysToastPresentation, "message" | "title" | "theme" | "copyText"> {
+    maxCount?: number;
+    maxQueue?: number;
+    overflow?: "replace" | "queue";
+    queueOrder?: "fifo" | "lifo";
+    queueScope?: "global" | "position" | "type" | "group";
+    layout?: "vertical" | "horizontal" | "layered";
+    gap?: number;
+    collapsedCount?: number;
+    layerCount?: number;
+    layerTrigger?: "hover" | "click" | "both";
+    grouping?: boolean;
+    dedupe?: "ignore" | "merge";
+    dedupeWindow?: number;
+    appendTo?: string | HTMLElement | ShadowRoot;
+}
+export interface HysToastHandle {
+    readonly id: string;
+    readonly closed: Promise<void>;
+    close(): void;
+    update(value: HysToastPatch): void;
+    extend(milliseconds: number): void;
+    pause(): void;
+    resume(): void;
+}
+export interface HysToastTaskContext {
+    handle: HysToastHandle;
+    update: (value: HysToastPatch) => void;
+    progress: (value: HysToastProgress) => void;
+}
+export interface HysToastPromiseOptions<T> {
+    id?: string;
+    options?: HysToastOptions;
+    loading?: HysToastPatch;
+    success?: HysToastFeedback<T>;
+    error?: HysToastFeedback<unknown>;
+}
+export interface HysToastTask<T> {
+    handle: HysToastHandle;
+    promise: Promise<T>;
+}
+type TypedToast = (value: string | Omit<HysToastOptions, "type">) => HysToastHandle;
+export interface HysToastApi {
+    show(value: string | HysToastOptions): HysToastHandle;
+    success: TypedToast;
+    info: TypedToast;
+    warning: TypedToast;
+    error: TypedToast;
+    loading: TypedToast;
+    promise<T>(task: PromiseLike<T> | ((context: HysToastTaskContext) => T | PromiseLike<T>), options?: HysToastPromiseOptions<T>): HysToastTask<T>;
+    close(id: string): void;
+    update(id: string, value: HysToastPatch): void;
+    find(id: string): HysToastSnapshot | undefined;
+    list(filter?: HysToastFilter): HysToastSnapshot[];
+    closeAll(filter?: HysToastFilter): void;
+    closeType(type: HysToastType): void;
+    clearQueue(): void;
+    configure(config: Partial<HysToastConfig>): void;
+}
+export interface HysToastServiceConfig extends HysToastConfig, HysConfig {
+}
+export interface HysToastService extends HysToastApi {
+    dispose(): void;
+}
+export {};

package/dist/types/components/HysToast/useToastActions.d.ts

@@ -0,0 +1,18 @@
+import type { HysToastAction, HysToastActionContext, HysToastActionEvent, HysToastContext, HysToastFeedback, HysToastLocale, HysToastPatch } from "./toastTypes";
+export declare function feedback<T>(value: HysToastFeedback<T> | undefined, result: T): Partial<Omit<import("./toastTypes").HysToastOptions, "id">> | undefined;
+export declare function useToastActions(options: {
+    available: () => boolean;
+    locale: () => HysToastLocale;
+    context: () => HysToastContext;
+    close: () => Promise<boolean>;
+    update: (patch: HysToastPatch) => void;
+    copyText: () => string;
+    emit: (event: HysToastActionEvent) => void;
+}): {
+    busy: import("vue").Ref<string | undefined, string | undefined>;
+    copyStatus: import("vue").Ref<string, string>;
+    copy: () => Promise<boolean>;
+    context: () => HysToastActionContext;
+    run: (action: HysToastAction) => Promise<void>;
+    reset: () => void;
+};

package/dist/types/components/HysToast/useToastSwipe.d.ts

@@ -0,0 +1,11 @@
+import { type Ref } from "vue";
+export declare function useToastSwipe(element: Ref<HTMLElement | undefined>, enabled: () => boolean, dismiss: (event: PointerEvent) => Promise<boolean>): {
+    shift: Ref<number, number>;
+    dragging: Ref<boolean, boolean>;
+    suppressClick: Ref<boolean, boolean>;
+    reset: () => void;
+    start: (event: PointerEvent) => void;
+    move: (event: PointerEvent) => void;
+    end: (event: PointerEvent) => Promise<void>;
+    leave: (event: PointerEvent) => void;
+};

package/dist/types/components/HysToast/useToastTimer.d.ts

@@ -0,0 +1,22 @@
+export type ToastClock = {
+    remaining: number;
+    total: number;
+    expired: boolean;
+};
+export declare function useToastTimer(options: {
+    running: () => boolean;
+    duration: () => number;
+    indicators: () => boolean;
+    pauseOnBlur: () => boolean;
+    expire: () => void;
+}): {
+    remaining: import("vue").Ref<number, number>;
+    total: import("vue").Ref<number, number>;
+    restart: () => void;
+    extend: (milliseconds: number) => void;
+    stop: () => void;
+    snapshot: () => ToastClock;
+    restore(clock: ToastClock): void;
+    pause: () => void;
+    resume: () => void;
+};

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

@@ -0,0 +1,9 @@
+type ReferenceListeners = {
+    [Name in keyof HTMLElementEventMap]?: (event: HTMLElementEventMap[Name]) => void;
+};
+export declare function createPopupReferenceBinding(kind: "tooltip" | "popover", id: string, events: ReferenceListeners): {
+    attach: (node: HTMLElement | undefined, open: boolean) => void;
+    detach: () => void;
+    syncAria: (open: boolean) => void;
+};
+export {};

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

@@ -1 +1 @@
-export declare function registerToastEscape(close: () => void): () => void;
+export declare function registerToastEscape(close: (event: KeyboardEvent) => void, element: () => HTMLElement | undefined): (() => void) | undefined;

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/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;
 };