@webx-ui/core 0.8.0 → 0.10.0

package/README.md

@@ -46,10 +46,28 @@ const title = ref('')
 `@webx-ui/core/style.css` already includes the token variables, so importing
 `@webx-ui/tokens/tokens.css` separately is optional.
 
-## Implemented
+## What is in it
 
-`WxButton`, `WxInput`, `WxCard`. The full component roadmap lives in
-[the docs](https://webx-ui.github.io/webx-ui/guide/roadmap.html).
+91 components — the form controls, the layout, the overlays, the data ones (`WxTable` takes
+Laravel's `paginate()` payload as it comes), and the ones an admin panel needs that Element Plus
+has no name for: `WxListDetail`, `WxKanban`, `WxEntityCard`, `WxSelectionArea`,
+`WxSortableList`. The [roadmap](https://webx-ui.github.io/webx-ui/guide/roadmap.html) lists every
+one of them and what is still open.
+
+Not everything is a component:
+
+```ts
+import { toast, confirm, openModal, createModal } from '@webx-ui/core'
+
+toast.success('Saved')
+if (await confirm('Delete this product?')) await api.delete(product)
+
+/* Any component, mounted from code and awaited for its answer. */
+const product = await createModal<Product>(ProductBrowser, { resolveOn: 'select' })()
+```
+
+One directive ships with the library, `v-wx-select`, which hands an item to the selection area
+around it. `app.use(WebxUI)` registers it along with the components.
 
 ## Conventions
 

package/dist/components/Affix/Affix.d.ts

@@ -0,0 +1,37 @@
+import { AffixProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: (props: {
+            stuck: boolean;
+        }) => unknown;
+    }> & {
+        default?: (props: {
+            stuck: boolean;
+        }) => unknown;
+    };
+    refs: {
+        sentinel: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AffixProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (stuck: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<AffixProps> & Readonly<{
+    onChange?: ((stuck: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    offset: number;
+    position: "top" | "bottom";
+    zIndex: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    sentinel: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Affix/index.d.ts

@@ -0,0 +1,2 @@
+export { default as WxAffix } from './Affix';
+export type * from './types';

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

@@ -0,0 +1,14 @@
+export interface AffixProps {
+    /** How far from the edge it comes to rest, in pixels. */
+    offset?: number;
+    /** Which edge it sticks to. */
+    position?: 'top' | 'bottom';
+    /** Puts the element back in the flow, whatever the scroll is doing. */
+    disabled?: boolean;
+    /** Layer it sits on once it is stuck. */
+    zIndex?: number;
+}
+export interface AffixEmits {
+    /** Fires when it sticks, and again when it lets go. */
+    change: [stuck: boolean];
+}

package/dist/components/Avatar/Avatar.d.ts

@@ -0,0 +1,31 @@
+import { AvatarProps, AvatarTone } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AvatarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<AvatarProps> & Readonly<{
+    onError?: ((event: Event) => any) | undefined;
+}>, {
+    name: string;
+    size: import('./types').AvatarSize;
+    icon: import('..').IconName;
+    tone: AvatarTone;
+    src: string;
+    alt: string;
+    shape: import('./types').AvatarShape;
+    fit: "cover" | "contain" | "fill" | "none" | "scale-down";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Avatar/index.d.ts

@@ -0,0 +1,2 @@
+export { default as WxAvatar } from './Avatar';
+export type * from './types';

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

@@ -0,0 +1,30 @@
+import { IconName } from '../Icon/types';
+export type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type AvatarShape = 'circle' | 'square';
+/**
+ * Colour of the fallback. `auto` picks a tint from the name, so the same person is
+ * the same colour on every screen and a list of them is readable at a glance.
+ */
+export type AvatarTone = 'auto' | 'neutral' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export interface AvatarProps {
+    /** Picture to show. Anything that fails to load falls through to the initials. */
+    src?: string;
+    /** Alternative text for the picture. Defaults to `name`. */
+    alt?: string;
+    /**
+     * Who this is. It supplies the initials, the tooltip-less title, and — with
+     * `tone="auto"` — the colour.
+     */
+    name?: string;
+    /** Shown instead of initials when there is no name. */
+    icon?: IconName;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    tone?: AvatarTone;
+    /** How the picture fills its box. */
+    fit?: 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+}
+export interface AvatarEmits {
+    /** The picture could not be loaded, so the fallback is showing. */
+    error: [event: Event];
+}

package/dist/components/AvatarGroup/AvatarGroup.d.ts

@@ -0,0 +1,8 @@
+import { AvatarGroupProps } from './types';
+declare const _default: import('vue').DefineComponent<AvatarGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AvatarGroupProps> & Readonly<{}>, {
+    size: import('..').AvatarSize;
+    shape: import('..').AvatarShape;
+    max: number;
+    overlap: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/AvatarGroup/index.d.ts

@@ -0,0 +1,2 @@
+export { default as WxAvatarGroup } from './AvatarGroup';
+export type * from './types';

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

@@ -0,0 +1,12 @@
+import { AvatarShape, AvatarSize } from '../Avatar/types';
+export interface AvatarGroupProps {
+    /**
+     * How many to show before the rest become a count. `0` shows every one of them.
+     */
+    max?: number;
+    /** Size for every avatar in the group; each one may still set its own. */
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    /** How far each avatar slides over the one before it, as a share of its width. */
+    overlap?: number;
+}

package/dist/components/Backtop/Backtop.d.ts

@@ -0,0 +1,31 @@
+import { BacktopProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => unknown;
+    }> & {
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BacktopProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BacktopProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    target: string | HTMLElement | null;
+    right: number;
+    bottom: number;
+    ariaLabel: string;
+    visibilityHeight: number;
+    smooth: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Backtop/index.d.ts

@@ -0,0 +1,2 @@
+export { default as WxBacktop } from './Backtop';
+export type * from './types';

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

@@ -0,0 +1,19 @@
+export interface BacktopProps {
+    /**
+     * What scrolls. A CSS selector, an element, or nothing for the window.
+     *
+     * Name it in an admin: the page there rarely scrolls — the main column does — and
+     * a button watching the window would appear when nothing has happened.
+     */
+    target?: string | HTMLElement | null;
+    /** How far down before the button appears, in pixels. */
+    visibilityHeight?: number;
+    /** Distance from the trailing edge, in pixels. */
+    right?: number;
+    /** Distance from the bottom, in pixels. */
+    bottom?: number;
+    /** Glides back up rather than jumping. */
+    smooth?: boolean;
+    /** Accessible name of the button. */
+    ariaLabel?: string;
+}

package/dist/components/Cascader/Cascader.d.ts

@@ -43,13 +43,13 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     clearable: boolean;
     status: import('../..').ControlStatus;
     id: string;
+    load: import('./types').CascaderLoader;
     separator: string;
     expandTrigger: "click" | "hover";
     checkStrictly: boolean;
     emitPath: boolean;
     showAllLevels: boolean;
     lazy: boolean;
-    load: import('./types').CascaderLoader;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     panel: HTMLDivElement;
 }, any>;

package/dist/components/CheckboxGroup/CheckboxGroup.d.ts

@@ -25,8 +25,8 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     disabled: boolean;
     options: import('./types').CheckboxOption[];
     inline: boolean;
-    min: number;
     max: number;
+    min: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/Descriptions/Descriptions.d.ts

@@ -0,0 +1,33 @@
+import { DescriptionsProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        title?: () => unknown;
+        /** Beside the heading: an edit button, a status. */
+        extra?: () => unknown;
+        default?: () => unknown;
+    }> & {
+        title?: () => unknown;
+        /** Beside the heading: an edit button, a status. */
+        extra?: () => unknown;
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DescriptionsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DescriptionsProps> & Readonly<{}>, {
+    bordered: boolean;
+    size: import('../..').ControlSize;
+    title: string;
+    columns: number;
+    layout: import('./types').DescriptionsLayout;
+    labelWidth: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Descriptions/context.d.ts

@@ -0,0 +1,5 @@
+import { InjectionKey } from 'vue';
+import { DescriptionsContext } from './types';
+export declare const descriptionsKey: InjectionKey<DescriptionsContext>;
+/** A pair on its own, outside any list, still has to render something sensible. */
+export declare function useDescriptions(): DescriptionsContext;

package/dist/components/Descriptions/index.d.ts

@@ -0,0 +1,2 @@
+export { default as WxDescriptions } from './Descriptions';
+export type * from './types';

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

@@ -0,0 +1,30 @@
+import { ControlSize } from '../../composables/useFormField';
+/** Where the label sits: beside its value, or above it. */
+export type DescriptionsLayout = 'horizontal' | 'vertical';
+export interface DescriptionsProps {
+    /** Heading above the list. */
+    title?: string;
+    /**
+     * How many label-and-value pairs stand side by side. The list drops to one column
+     * on its own when the room runs out, so this is the most it will ever show.
+     */
+    columns?: number;
+    /** Rules around every cell, which is what turns a list into a table of facts. */
+    bordered?: boolean;
+    size?: ControlSize;
+    layout?: DescriptionsLayout;
+    /** Width of the label column when the layout is `horizontal`, e.g. `"140px"`. */
+    labelWidth?: string;
+}
+export interface DescriptionsItemProps {
+    /** The name of the fact. Use the `label` slot for anything richer than text. */
+    label?: string;
+    /** How many columns the pair takes up. */
+    span?: number;
+}
+/** What `WxDescriptions` hands down to the pairs inside it. */
+export interface DescriptionsContext {
+    bordered: boolean;
+    layout: DescriptionsLayout;
+    labelWidth: string | undefined;
+}

package/dist/components/DescriptionsItem/DescriptionsItem.d.ts

@@ -0,0 +1,25 @@
+import { DescriptionsItemProps } from '../Descriptions/types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        label?: () => unknown;
+        default?: () => unknown;
+    }> & {
+        label?: () => unknown;
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DescriptionsItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DescriptionsItemProps> & Readonly<{}>, {
+    label: string;
+    span: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DescriptionsItem/index.d.ts

@@ -0,0 +1 @@
+export { default as WxDescriptionsItem } from './DescriptionsItem';

package/dist/components/Empty/Empty.d.ts

@@ -0,0 +1,38 @@
+import { EmptyProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Replaces the glyph — an illustration, a logo, whatever says it better. */
+        icon?: () => unknown;
+        title?: () => unknown;
+        /** The explanation. Overrides `description`. */
+        default?: () => unknown;
+        /** What to do about it: a button that clears the filter, one that adds a record. */
+        actions?: () => unknown;
+    }> & {
+        /** Replaces the glyph — an illustration, a logo, whatever says it better. */
+        icon?: () => unknown;
+        title?: () => unknown;
+        /** The explanation. Overrides `description`. */
+        default?: () => unknown;
+        /** What to do about it: a button that clears the filter, one that adds a record. */
+        actions?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<EmptyProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<EmptyProps> & Readonly<{}>, {
+    plain: boolean;
+    size: import('./types').EmptySize;
+    title: string;
+    icon: import('..').IconName;
+    description: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Empty/index.d.ts

@@ -0,0 +1,2 @@
+export { default as WxEmpty } from './Empty';
+export type * from './types';

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

@@ -0,0 +1,20 @@
+import { IconName } from '../Icon/types';
+export type EmptySize = 'sm' | 'md' | 'lg';
+export interface EmptyProps {
+    /**
+     * The glyph above the message. Pick one that says what is missing — `search` for
+     * a filter that matched nothing, `inbox` for a list nobody has written to yet.
+     */
+    icon?: IconName;
+    /** What is missing, in a few words. */
+    title?: string;
+    /** Why, or what to do about it. */
+    description?: string;
+    /**
+     * How much room to take. `sm` is a panel inside a screen; `lg` is a whole page
+     * with nothing on it.
+     */
+    size?: EmptySize;
+    /** Drops the icon, for a message that stands on its own. */
+    plain?: boolean;
+}

package/dist/components/EntityCard/EntityCard.d.ts

@@ -26,8 +26,8 @@ declare const __VLS_component: import('vue').DefineComponent<EntityCardProps, {}
     title: string;
     subtitle: string;
     href: string;
-    imageAlt: string;
     shape: import('./types').EntityCardShape;
+    imageAlt: string;
     imageSize: number | string;
     selected: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;

package/dist/components/Form/Form.d.ts

@@ -18,9 +18,9 @@ declare const __VLS_component: import('vue').DefineComponent<FormProps, {}, {},
 }>, {
     size: import('../..').ControlSize;
     disabled: boolean;
+    labelWidth: string;
     errors: ValidationErrors;
     labelPosition: "top" | "left";
-    labelWidth: string;
     gap: "sm" | "md" | "lg";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLFormElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/dist/components/Image/Image.d.ts

@@ -0,0 +1,43 @@
+import { ImageProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Shown while the picture is on its way. */
+        placeholder?: () => unknown;
+        /** Shown instead of a picture that will not load. */
+        error?: () => unknown;
+    }> & {
+        /** Shown while the picture is on its way. */
+        placeholder?: () => unknown;
+        /** Shown instead of a picture that will not load. */
+        error?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ImageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (event: Event) => any;
+    load: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<ImageProps> & Readonly<{
+    onError?: ((event: Event) => any) | undefined;
+    onLoad?: ((event: Event) => any) | undefined;
+}>, {
+    placeholder: string;
+    width: number | string;
+    src: string;
+    alt: string;
+    fit: import('./types').ImageFit;
+    lazy: boolean;
+    preview: boolean;
+    height: number | string;
+    radius: number | string;
+    previewLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Image/index.d.ts

@@ -0,0 +1,2 @@
+export { default as WxImage } from './Image';
+export type * from './types';

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

@@ -0,0 +1,26 @@
+export type ImageFit = 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+export interface ImageProps {
+    src?: string;
+    alt?: string;
+    /** How the picture fills its box. */
+    fit?: ImageFit;
+    width?: number | string;
+    height?: number | string;
+    /** Shape of the box: any CSS length, or a keyword from the radius scale. */
+    radius?: number | string;
+    /**
+     * Waits until the picture is near the screen before fetching it. On by default:
+     * a media library is a hundred pictures and a reader looks at four.
+     */
+    lazy?: boolean;
+    /** A tiny picture — or a colour — shown while the real one arrives. */
+    placeholder?: string;
+    /** Opens the picture full size when it is clicked. */
+    preview?: boolean;
+    /** Accessible name of the button that opens the preview. */
+    previewLabel?: string;
+}
+export interface ImageEmits {
+    load: [event: Event];
+    error: [event: Event];
+}

package/dist/components/Indicator/Indicator.d.ts

@@ -15,8 +15,8 @@ declare const __VLS_component: import('vue').DefineComponent<IndicatorProps, {},
     value: number | string;
     hidden: boolean;
     offset: [number, number];
-    dot: boolean;
     max: number;
+    dot: boolean;
     showZero: boolean;
     placement: import('./types').IndicatorPlacement;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;

package/dist/components/InputNumber/InputNumber.d.ts

@@ -27,12 +27,12 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
     ariaLabel: string;
     status: import('../..').ControlStatus;
     id: string;
-    min: number;
     max: number;
+    wheel: boolean;
+    min: number;
     readonly: boolean;
     step: number;
     precision: number;
-    wheel: boolean;
     controls: boolean;
     controlsPosition: "sides" | "right";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {

package/dist/components/Loading/Loading.d.ts

@@ -0,0 +1,34 @@
+import { LoadingProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** What is being covered. Left out for a spinner on its own. */
+        default?: () => unknown;
+        /** Replaces the spinner. */
+        spinner?: () => unknown;
+    }> & {
+        /** What is being covered. Left out for a spinner on its own. */
+        default?: () => unknown;
+        /** Replaces the spinner. */
+        spinner?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<LoadingProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LoadingProps> & Readonly<{}>, {
+    size: import('./types').LoadingSize;
+    text: string;
+    ariaLabel: string;
+    loading: boolean;
+    blur: boolean;
+    delay: number;
+    fullscreen: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Loading/index.d.ts

@@ -0,0 +1,2 @@
+export { default as WxLoading } from './Loading';
+export type * from './types';

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

@@ -0,0 +1,25 @@
+export type LoadingSize = 'sm' | 'md' | 'lg';
+export interface LoadingProps {
+    /** Whether the veil is up. */
+    loading?: boolean;
+    /** What is being waited for. Shown under the spinner. */
+    text?: string;
+    size?: LoadingSize;
+    /**
+     * Covers the whole window rather than the box it sits in. For a route change,
+     * not for a panel refreshing.
+     */
+    fullscreen?: boolean;
+    /**
+     * How long the work may take before the veil appears, in milliseconds. Anything
+     * that answers quickly should not flash a spinner on the way.
+     */
+    delay?: number;
+    /**
+     * Blurs what is underneath instead of only fading it. Reads as "this is on its
+     * way out" rather than "this is broken".
+     */
+    blur?: boolean;
+    /** Accessible description of the wait. */
+    ariaLabel?: string;
+}