veload 0.0.0-stage → 0.1.0

package/dist/components/VLoader/index.vue.d.ts

@@ -0,0 +1,12 @@
+import { type VLoaderProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VLoaderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VLoaderProps> & Readonly<{}>, {
+    size: number;
+    color: string;
+    label: string;
+    decorative: boolean;
+    variant: "bars" | "blob" | "bounce" | "breathing" | "card-flip" | "dot-sweep" | "dots" | "dual-arc" | "element" | "equalizer" | "fallback" | "flow" | "gradient-ring" | "grid" | "hashtag" | "heatmap" | "liquid" | "logo-spin" | "morph" | "orbit-dots" | "orbit" | "plane" | "progress-ring" | "pulse" | "ring" | "ripple" | "rotate" | "signal" | "sliding-bars" | "snake" | "spin-dots" | "spin" | "squares" | "stair" | "typing" | "wave";
+    value: number | null;
+    duration: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VLoader/loaders.d.ts

@@ -0,0 +1,38 @@
+import { type DefineComponent } from "vue";
+import type { NamedLoaderProps } from "./types";
+export declare const VBarsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VBlobLoader: DefineComponent<NamedLoaderProps>;
+export declare const VBounceLoader: DefineComponent<NamedLoaderProps>;
+export declare const VBreathingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VCardFlipLoader: DefineComponent<NamedLoaderProps>;
+export declare const VDotSweepLoader: DefineComponent<NamedLoaderProps>;
+export declare const VDotsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VDualArcLoader: DefineComponent<NamedLoaderProps>;
+export declare const VElementLoader: DefineComponent<NamedLoaderProps>;
+export declare const VEqualizerLoader: DefineComponent<NamedLoaderProps>;
+export declare const VFallbackLoader: DefineComponent<NamedLoaderProps>;
+export declare const VFlowLoader: DefineComponent<NamedLoaderProps>;
+export declare const VGradientRingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VGridLoader: DefineComponent<NamedLoaderProps>;
+export declare const VHashtagLoader: DefineComponent<NamedLoaderProps>;
+export declare const VHeatmapLoader: DefineComponent<NamedLoaderProps>;
+export declare const VLiquidLoader: DefineComponent<NamedLoaderProps>;
+export declare const VLogoSpinLoader: DefineComponent<NamedLoaderProps>;
+export declare const VMorphLoader: DefineComponent<NamedLoaderProps>;
+export declare const VOrbitDotsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VOrbitLoader: DefineComponent<NamedLoaderProps>;
+export declare const VPlaneLoader: DefineComponent<NamedLoaderProps>;
+export declare const VProgressRingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VPulseLoader: DefineComponent<NamedLoaderProps>;
+export declare const VRingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VRippleLoader: DefineComponent<NamedLoaderProps>;
+export declare const VRotateLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSignalLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSlidingBarsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSnakeLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSpinDotsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSpinLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSquaresLoader: DefineComponent<NamedLoaderProps>;
+export declare const VStairLoader: DefineComponent<NamedLoaderProps>;
+export declare const VTypingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VWaveLoader: DefineComponent<NamedLoaderProps>;

package/dist/components/VLoader/types.d.ts

@@ -0,0 +1,28 @@
+export declare const loaderVariants: readonly ["bars", "blob", "bounce", "breathing", "card-flip", "dot-sweep", "dots", "dual-arc", "element", "equalizer", "fallback", "flow", "gradient-ring", "grid", "hashtag", "heatmap", "liquid", "logo-spin", "morph", "orbit-dots", "orbit", "plane", "progress-ring", "pulse", "ring", "ripple", "rotate", "signal", "sliding-bars", "snake", "spin-dots", "spin", "squares", "stair", "typing", "wave"];
+export type LoaderVariant = (typeof loaderVariants)[number];
+export interface VLoaderProps {
+    /** Visual treatment used by the loader. */
+    variant?: LoaderVariant;
+    /** Primary color. @default "currentColor" */
+    color?: string;
+    /** Base size in pixels; repeated treatments may grow to fit count. @default 40 */
+    size?: number;
+    /** Animation duration in milliseconds. @default 1000 */
+    duration?: number;
+    /** Accessible name announced by the status region. @default "Loading" */
+    label?: string;
+    /** Hides the loader from assistive technology. @default false */
+    decorative?: boolean;
+    /** Repeated marks, rounded and clamped to 1–12. Fixed-shape treatments ignore it. @default 4 */
+    count?: number;
+    /** Optional completion value for the progress-ring treatment, from 0 to 100. */
+    value?: number | null;
+}
+export type NamedLoaderProps = Omit<VLoaderProps, "variant">;
+/** Props shared by treatments that render repeated marks. */
+export type VMarkLoaderProps = Omit<NamedLoaderProps, "value">;
+/** Props specific to the determinate or indeterminate progress-ring treatment. */
+export interface VProgressRingLoaderProps extends Omit<NamedLoaderProps, "value"> {
+    /** Completion percentage from 0 to 100. Omit for an indeterminate ring. */
+    value?: number | null;
+}

package/dist/components/VLoading/index.vue.d.ts

@@ -0,0 +1,21 @@
+import type { VLoadingProps } from "./types";
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    indicator?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<VLoadingProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VLoadingProps> & Readonly<{}>, {
+    label: string;
+    loading: boolean;
+    inertContent: boolean;
+    indicatorSize: number;
+}, {}, {}, {}, 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/components/VLoading/types.d.ts

@@ -0,0 +1,27 @@
+export interface VLoadingProps {
+    /**
+     * Whether the loading overlay is active.
+     *
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Accessible loading message. The text is visually hidden by default.
+     *
+     * @default "Loading"
+     */
+    label?: string;
+    /**
+     * Makes the wrapped content inert while the overlay is active. This prevents
+     * pointer and keyboard interaction with content beneath the overlay.
+     *
+     * @default true
+     */
+    inertContent?: boolean;
+    /**
+     * Diameter of the default spinner in pixels.
+     *
+     * @default 28
+     */
+    indicatorSize?: number;
+}

package/dist/components/VLoadingButton/index.vue.d.ts

@@ -0,0 +1,21 @@
+import type { LoadingButtonType, VLoadingButtonProps } from "./types";
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    indicator?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<VLoadingButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VLoadingButtonProps> & Readonly<{}>, {
+    type: LoadingButtonType;
+    loading: boolean;
+    indicatorSize: number;
+    disabled: 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/components/VLoadingButton/types.d.ts

@@ -0,0 +1,29 @@
+export type LoadingButtonType = "button" | "submit" | "reset";
+export interface VLoadingButtonProps {
+    /**
+     * Whether the button is performing work. While loading, the button is
+     * disabled, exposes `aria-busy`, and shows an indicator.
+     *
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Native disabled state. The button is also disabled while loading.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Native button type. Defaults to `"button"` so the component does not
+     * accidentally submit a surrounding form.
+     *
+     * @default "button"
+     */
+    type?: LoadingButtonType;
+    /**
+     * Diameter of the default indicator in pixels.
+     *
+     * @default 16
+     */
+    indicatorSize?: number;
+}

package/dist/components/VPatternSkeleton/index.vue.d.ts

@@ -0,0 +1,18 @@
+import type { SkeletonPattern, VPatternSkeletonProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VPatternSkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VPatternSkeletonProps> & Readonly<{}>, {
+    pattern: SkeletonPattern;
+    animated: boolean;
+    rows: number;
+    columns: number;
+    showMedia: boolean;
+    showAvatar: boolean;
+    showHeader: boolean;
+    showChart: boolean;
+    showStats: boolean;
+    showSubmit: boolean;
+    showRating: boolean;
+    showPrice: boolean;
+    showCta: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VPatternSkeleton/presets.d.ts

@@ -0,0 +1,26 @@
+import { type DefineComponent } from "vue";
+import type { VSkeletonSwitchProps } from "../VSkeletonSwitch/types";
+import type { VArticleSkeletonProps, VCardSkeletonProps, VDashboardSkeletonProps, VFeedSkeletonProps, VFormSkeletonProps, VListSkeletonProps, VMediaCardSkeletonProps, VProductCardSkeletonProps, VProfileSkeletonProps, VTableSkeletonProps } from "./types";
+export declare const VSkeletonLoader: DefineComponent<import("../VSkeleton/types.js").VSkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("../VSkeleton/types.js").VSkeletonProps> & Readonly<{}>, {
+    variant: import("../VSkeleton/types.js").SkeletonVariant;
+    animated: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export declare const VArticleSkeleton: DefineComponent<VArticleSkeletonProps>;
+export declare const VCardSkeleton: DefineComponent<VCardSkeletonProps>;
+export declare const VDashboardSkeleton: DefineComponent<VDashboardSkeletonProps>;
+export declare const VFeedSkeleton: DefineComponent<VFeedSkeletonProps>;
+export declare const VFormSkeleton: DefineComponent<VFormSkeletonProps>;
+export declare const VListSkeleton: DefineComponent<VListSkeletonProps>;
+export declare const VMediaCardSkeleton: DefineComponent<VMediaCardSkeletonProps>;
+export declare const VProductCardSkeleton: DefineComponent<VProductCardSkeletonProps>;
+export declare const VProfileSkeleton: DefineComponent<VProfileSkeletonProps>;
+export declare const VTableSkeleton: DefineComponent<VTableSkeletonProps>;
+/**
+ * A safe content switcher for Vue skeleton states.
+ *
+ * Unlike React Loadly's experimental DOM-inference API, this component never
+ * executes or inspects slot content. It renders a supplied skeleton slot or a
+ * selected Veloader pattern while loading, then renders the default slot.
+ */
+export type VAutoSkeletonProps = VSkeletonSwitchProps;
+export declare const VAutoSkeleton: DefineComponent<VAutoSkeletonProps>;

package/dist/components/VPatternSkeleton/types.d.ts

@@ -0,0 +1,48 @@
+export type SkeletonPattern = "lines" | "article" | "card" | "profile" | "list" | "table" | "media" | "form" | "dashboard" | "feed" | "product";
+export interface SkeletonAppearanceProps {
+    color?: string;
+    highlightColor?: string;
+    animated?: boolean;
+    label?: string;
+}
+export interface VPatternSkeletonProps extends SkeletonAppearanceProps {
+    /** Layout pattern. @default "lines" */
+    pattern?: SkeletonPattern;
+    /** Repeated lines, items, fields, or data rows (1–12). Table/dashboard headers are separate; dashboard always includes one header. @default 3 */
+    rows?: number;
+    /** Table column count. @default 3 */
+    columns?: number;
+    /** Image or media height in pixels or a CSS length. */
+    mediaHeight?: number | string;
+    /** Avatar diameter in pixels. */
+    avatarSize?: number;
+    /** Enables optional media blocks where the pattern supports them. @default true */
+    showMedia?: boolean;
+    /** Enables optional avatar blocks where the pattern supports them. @default true */
+    showAvatar?: boolean;
+    /** Enables a table header. @default true */
+    showHeader?: boolean;
+    /** Enables the dashboard chart block. @default true */
+    showChart?: boolean;
+    /** Enables profile or dashboard statistic blocks. @default true */
+    showStats?: boolean;
+    /** Enables the form submit block. @default true */
+    showSubmit?: boolean;
+    /** Enables the product rating block. @default true */
+    showRating?: boolean;
+    /** Enables the product price block. @default true */
+    showPrice?: boolean;
+    /** Enables the product call-to-action block. @default true */
+    showCta?: boolean;
+}
+export type NamedSkeletonProps = Omit<VPatternSkeletonProps, "pattern">;
+export type VArticleSkeletonProps = Pick<NamedSkeletonProps, "rows" | "mediaHeight" | "showMedia"> & SkeletonAppearanceProps;
+export type VCardSkeletonProps = Pick<NamedSkeletonProps, "rows" | "mediaHeight" | "showMedia" | "showAvatar"> & SkeletonAppearanceProps;
+export type VDashboardSkeletonProps = Pick<NamedSkeletonProps, "rows" | "columns" | "showChart" | "showStats"> & SkeletonAppearanceProps;
+export type VFeedSkeletonProps = Pick<NamedSkeletonProps, "rows" | "showAvatar"> & SkeletonAppearanceProps;
+export type VFormSkeletonProps = Pick<NamedSkeletonProps, "rows" | "showSubmit"> & SkeletonAppearanceProps;
+export type VListSkeletonProps = Pick<NamedSkeletonProps, "rows" | "showAvatar" | "avatarSize"> & SkeletonAppearanceProps;
+export type VMediaCardSkeletonProps = Pick<NamedSkeletonProps, "rows" | "mediaHeight"> & SkeletonAppearanceProps;
+export type VProductCardSkeletonProps = Pick<NamedSkeletonProps, "mediaHeight" | "showRating" | "showPrice" | "showCta"> & SkeletonAppearanceProps;
+export type VProfileSkeletonProps = Pick<NamedSkeletonProps, "rows" | "avatarSize" | "showStats"> & SkeletonAppearanceProps;
+export type VTableSkeletonProps = Pick<NamedSkeletonProps, "rows" | "columns" | "showHeader"> & SkeletonAppearanceProps;

package/dist/components/VProgress/index.vue.d.ts

@@ -0,0 +1,10 @@
+import type { VProgressProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VProgressProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VProgressProps> & Readonly<{}>, {
+    label: string;
+    height: string | number;
+    value: number | null;
+    min: number;
+    max: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VProgress/types.d.ts

@@ -0,0 +1,45 @@
+export interface VProgressProps {
+    /**
+     * Current progress value. Omit, pass `null`, or pass a non-finite value to
+     * render an indeterminate progress bar.
+     */
+    value?: number | null;
+    /**
+     * Lower bound of the value range.
+     *
+     * @default 0
+     */
+    min?: number;
+    /**
+     * Upper bound of the value range. When `max` is not greater than `min`, the
+     * bar renders as indeterminate.
+     *
+     * @default 100
+     */
+    max?: number;
+    /**
+     * Accessible name for the progress bar.
+     *
+     * @default "Progress"
+     */
+    label?: string;
+    /**
+     * Optional human-readable value text, for example `"3 of 10 files"`.
+     * Only applied while determinate.
+     */
+    valueText?: string;
+    /**
+     * Thickness of the bar as a pixel number or any CSS length.
+     *
+     * @default 8
+     */
+    height?: number | string;
+    /**
+     * Color of the filled portion. Overrides `--v-progress-color`.
+     */
+    color?: string;
+    /**
+     * Color of the unfilled track. Overrides `--v-progress-track-color`.
+     */
+    trackColor?: string;
+}

package/dist/components/VSkeleton/index.vue.d.ts

@@ -0,0 +1,7 @@
+import type { SkeletonVariant, VSkeletonProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VSkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VSkeletonProps> & Readonly<{}>, {
+    variant: SkeletonVariant;
+    animated: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VSkeleton/types.d.ts

@@ -0,0 +1,37 @@
+export type SkeletonVariant = "text" | "rect" | "circle";
+export interface VSkeletonProps {
+    /**
+     * Shape of the placeholder.
+     *
+     * @default "text"
+     */
+    variant?: SkeletonVariant;
+    /**
+     * Width as a pixel number or any CSS length. Defaults to `100%`, except for
+     * circular skeletons, which default to `40px`.
+     */
+    width?: number | string;
+    /**
+     * Height as a pixel number or any CSS length. Circular skeletons use a
+     * square aspect ratio when no height is supplied.
+     */
+    height?: number | string;
+    /**
+     * Border radius as a pixel number or any CSS length. When omitted, a shape
+     * appropriate default is used.
+     */
+    borderRadius?: number | string;
+    /**
+     * Enables the shimmer animation. Reduced-motion preferences always disable
+     * the animation in CSS.
+     *
+     * @default true
+     */
+    animated?: boolean;
+    /**
+     * Optional accessible name. When supplied, the skeleton becomes a
+     * `role="status"` placeholder. When omitted, it is decorative and hidden
+     * from assistive technology.
+     */
+    label?: string;
+}

package/dist/components/VSkeletonGroup/index.vue.d.ts

@@ -0,0 +1,17 @@
+import type { VSkeletonGroupProps } from "./types";
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<VSkeletonGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VSkeletonGroupProps> & Readonly<{}>, {
+    decorative: boolean;
+    gap: 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/components/VSkeletonGroup/types.d.ts

@@ -0,0 +1,8 @@
+export interface VSkeletonGroupProps {
+    /** Accessible loading message for the complete group. */
+    label?: string;
+    /** CSS gap between child placeholders. @default "0.75rem" */
+    gap?: string;
+    /** Hides the entire group from assistive technology. @default false */
+    decorative?: boolean;
+}

package/dist/components/VSkeletonSwitch/index.vue.d.ts

@@ -0,0 +1,31 @@
+import type { VSkeletonSwitchProps } from "./types";
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    skeleton?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<VSkeletonSwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VSkeletonSwitchProps> & Readonly<{}>, {
+    label: string;
+    pattern: import("../VPatternSkeleton/types.js").SkeletonPattern;
+    animated: boolean;
+    loading: boolean;
+    rows: number;
+    showMedia: boolean;
+    showAvatar: boolean;
+    showHeader: boolean;
+    showChart: boolean;
+    showStats: boolean;
+    showSubmit: boolean;
+    showRating: boolean;
+    showPrice: boolean;
+    showCta: 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/components/VSkeletonSwitch/types.d.ts

@@ -0,0 +1,5 @@
+import type { VPatternSkeletonProps } from "../VPatternSkeleton/types";
+export interface VSkeletonSwitchProps extends VPatternSkeletonProps {
+    /** Whether to show the skeleton slot or pattern. @default true */
+    loading?: boolean;
+}

package/dist/components/VSpinner/index.vue.d.ts

@@ -0,0 +1,9 @@
+import type { VSpinnerProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VSpinnerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VSpinnerProps> & Readonly<{}>, {
+    size: number;
+    color: string;
+    label: string;
+    decorative: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VSpinner/types.d.ts

@@ -0,0 +1,29 @@
+export interface VSpinnerProps {
+    /**
+     * Diameter of the spinner in pixels. Non-finite and negative values are
+     * safely normalized.
+     *
+     * @default 24
+     */
+    size?: number;
+    /**
+     * Accent color of the active edge. The remaining track uses
+     * `--v-spinner-track-color` (falling back to `currentColor`).
+     *
+     * @default "currentColor"
+     */
+    color?: string;
+    /**
+     * Accessible name announced by the status element.
+     *
+     * @default "Loading"
+     */
+    label?: string;
+    /**
+     * Hides the spinner from assistive technology. Use this when an ancestor
+     * already exposes a loading status, such as `VLoading`.
+     *
+     * @default false
+     */
+    decorative?: boolean;
+}

package/dist/composables/useDelayedLoading.d.ts

@@ -0,0 +1,32 @@
+import type { UseLoadingReturn } from "./useLoading";
+export interface UseDelayedLoadingOptions {
+    /**
+     * Delay in milliseconds before the loading indicator becomes visible.
+     * Negative values are treated as `0`; non-finite values use the default.
+     *
+     * @default 200
+     */
+    delay?: number;
+    /**
+     * Minimum time in milliseconds the loading indicator remains visible once
+     * it has appeared. This prevents a brief flash when an operation finishes
+     * just after the delay. `0` disables the minimum.
+     *
+     * The minimum is measured from the moment the indicator becomes visible,
+     * not from the moment the operation starts.
+     *
+     * @default 0
+     */
+    minVisibleDuration?: number;
+}
+export type UseDelayedLoadingReturn = UseLoadingReturn;
+/**
+ * Tracks asynchronous operations like {@link useLoading}, but delays showing
+ * the loading indicator until the work has remained pending for `delay`
+ * milliseconds.
+ *
+ * The operation itself starts immediately. Once visible, the indicator can be
+ * kept on screen for at least `minVisibleDuration` milliseconds to avoid a
+ * short flash.
+ */
+export declare function useDelayedLoading(options?: UseDelayedLoadingOptions | number): UseDelayedLoadingReturn;

package/dist/composables/useLoading.d.ts

@@ -0,0 +1,28 @@
+import { type Ref } from "vue";
+/**
+ * Reactive state returned by {@link useLoading}.
+ */
+export interface UseLoadingReturn {
+    /**
+     * `true` while at least one tracked operation is pending.
+     */
+    isLoading: Readonly<Ref<boolean>>;
+    /**
+     * Number of currently pending operations for this instance.
+     */
+    pendingCount: Readonly<Ref<number>>;
+    /**
+     * Runs an asynchronous operation and tracks it until it settles.
+     *
+     * The operation's return value and rejection reason are preserved.
+     */
+    execute: <T>(operation: () => Promise<T>) => Promise<T>;
+}
+/**
+ * Tracks concurrent asynchronous operations for a single loading state.
+ *
+ * Each call to `execute` increments the pending count before invoking the
+ * operation and decrements it in a `finally` block. The operation result or
+ * error is passed through unchanged.
+ */
+export declare function useLoading(): UseLoadingReturn;

package/dist/composables/useLoadingGroup.d.ts

@@ -0,0 +1,25 @@
+import { type ComputedRef, type Ref } from "vue";
+/**
+ * A reactive boolean source or a getter that returns one.
+ *
+ * Typically this is the `isLoading` ref from another composable instance.
+ */
+export type LoadingSource = Readonly<Ref<boolean>> | (() => boolean);
+export interface UseLoadingGroupReturn {
+    /**
+     * `true` when at least one source is active.
+     */
+    isLoading: ComputedRef<boolean>;
+    /**
+     * Number of sources that are currently active.
+     */
+    activeCount: ComputedRef<number>;
+}
+/**
+ * Aggregates independent loading sources into a single loading state.
+ *
+ * Pass an array for a fixed set of sources, or a getter when the set of
+ * sources changes dynamically. The group does not own the sources; it only
+ * reads them.
+ */
+export declare function useLoadingGroup(sources: readonly LoadingSource[] | (() => readonly LoadingSource[])): UseLoadingGroupReturn;