@webx-ui/core 0.7.0 → 0.9.0

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

@@ -0,0 +1,19 @@
+export interface ListDetailProps {
+    /**
+     * Width of the column that narrows the list: saved views, filters, folders.
+     * The column is only rendered when the `filters` slot is used.
+     */
+    filtersWidth?: number | string;
+    /** Width of the list of records. */
+    listWidth?: number | string;
+    /**
+     * The narrowest the detail pane may be. It is what the two thresholds are made
+     * of: the filters column folds away when it would push the pane under this, and
+     * the pane stops standing beside the list when it no longer fits either.
+     */
+    detailMin?: number;
+    /** Heading of the panel the filters move into once the column does not fit. */
+    filtersTitle?: string;
+    /** Accessible name of the panel the detail opens in on a narrow screen. */
+    detailLabel?: string;
+}

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

package/dist/components/Menu/Menu.d.ts

@@ -10,7 +10,9 @@ declare function __VLS_template(): {
     slots: {
         default?(_: {}): any;
     };
-    refs: {};
+    refs: {
+        list: HTMLUListElement;
+    };
     rootEl: HTMLUListElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
@@ -27,9 +29,13 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     label: string;
     collapsed: boolean;
     mode: import('./types').MenuMode;
+    overflow: import('./types').MenuOverflow;
+    overflowTitle: string;
     accordion: boolean;
     autoExpand: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLUListElement>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    list: HTMLUListElement;
+}, HTMLUListElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

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

@@ -1,10 +1,20 @@
 import { MenuMode, MenuSize, MenuValue } from '../../composables/useMenu';
 export type { MenuMode, MenuSize, MenuValue };
+/**
+ * What a bar does with entries it has no room for: move them into a branch at the
+ * end of it, or let the bar scroll sideways. Vertical menus ignore this — a column
+ * has as much room as it needs.
+ */
+export type MenuOverflow = 'menu' | 'scroll';
 export interface MenuProps {
     /** A sidebar down the page, or a bar across the top of it. */
     mode?: MenuMode;
     /** Row height and text size. */
     size?: MenuSize;
+    /** What a bar does with the entries that do not fit across it. */
+    overflow?: MenuOverflow;
+    /** Title of the branch those entries move into. */
+    overflowTitle?: string;
     /**
      * The icon rail: labels are hidden and submenus open as flyouts beside the rail.
      * Vertical menus only — there is nothing to collapse in a bar.

package/dist/components/Popconfirm/Popconfirm.d.ts

@@ -0,0 +1,69 @@
+import { PopconfirmProps } from './types';
+type __VLS_Props = PopconfirmProps;
+declare function cancel(): void;
+type __VLS_PublicProps = {
+    'open'?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** The control that asks. Exactly one element. */
+        trigger?: (props: {
+            open: boolean;
+        }) => unknown;
+        /** Replaces the question and its explanation. */
+        default?: () => unknown;
+        /** Replaces the two buttons. */
+        actions?: (props: {
+            confirm: () => void;
+            cancel: () => void;
+        }) => unknown;
+    }> & {
+        /** The control that asks. Exactly one element. */
+        trigger?: (props: {
+            open: boolean;
+        }) => unknown;
+        /** Replaces the question and its explanation. */
+        default?: () => unknown;
+        /** Replaces the two buttons. */
+        actions?: (props: {
+            confirm: () => void;
+            cancel: () => void;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    close: typeof cancel;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    cancel: () => any;
+    confirm: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    title: string;
+    icon: import('..').IconName | false;
+    side: import('..').PopoverSide;
+    align: import('..').PopoverAlign;
+    offset: number;
+    description: string;
+    width: number | string;
+    loading: boolean;
+    confirmText: string;
+    cancelText: string;
+    confirmType: import('..').ButtonType;
+    arrow: 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/Popconfirm/index.d.ts

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

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

@@ -0,0 +1,33 @@
+import { ButtonType } from '../Button/types';
+import { IconName } from '../Icon/types';
+import { PopoverAlign, PopoverSide } from '../Popover/types';
+export interface PopconfirmProps {
+    /** The question. Keep it about what will happen, not about the button. */
+    title?: string;
+    /** What else the reader should know before answering. */
+    description?: string;
+    /** Label of the button that goes ahead. */
+    confirmText?: string;
+    /** Label of the button that does not. */
+    cancelText?: string;
+    /** Colour of the confirming button — `danger` for anything that destroys. */
+    confirmType?: ButtonType;
+    /** The glyph beside the question. `false` drops it. */
+    icon?: IconName | false;
+    side?: PopoverSide;
+    align?: PopoverAlign;
+    /** Distance from the trigger, in pixels. */
+    offset?: number;
+    /** Draws the little pointer at the trigger. */
+    arrow?: boolean;
+    /** Width of the panel: a number in pixels, or any CSS length. */
+    width?: number | string;
+    /** The trigger stops asking anything. */
+    disabled?: boolean;
+    /** Keeps the panel open and the confirming button busy — for an async answer. */
+    loading?: boolean;
+}
+export interface PopconfirmEmits {
+    confirm: [];
+    cancel: [];
+}

package/dist/components/Progress/Progress.d.ts

@@ -0,0 +1,41 @@
+import { ProgressProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Replaces the figure — a count, a size, a time remaining. */
+        default?: (props: {
+            value: number;
+            max: number;
+            percent: number;
+        }) => unknown;
+    }> & {
+        /** Replaces the figure — a count, a size, a time remaining. */
+        default?: (props: {
+            value: number;
+            max: number;
+            percent: number;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ProgressProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ProgressProps> & Readonly<{}>, {
+    size: import('./types').ProgressSize;
+    type: import('./types').ProgressType;
+    value: number;
+    ariaLabel: string;
+    status: import('./types').ProgressStatus;
+    max: number;
+    indeterminate: boolean;
+    formatter: (value: number, max: number) => string;
+    thickness: number;
+    showValue: 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/Progress/index.d.ts

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

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

@@ -0,0 +1,26 @@
+export type ProgressType = 'line' | 'circle';
+export type ProgressStatus = 'default' | 'success' | 'warning' | 'danger';
+export type ProgressSize = 'sm' | 'md' | 'lg';
+export interface ProgressProps {
+    /** How far along, from `0` to `max`. */
+    value?: number;
+    /** What finished looks like. */
+    max?: number;
+    type?: ProgressType;
+    /** Colour of the bar. `success` and `danger` are outcomes, not decorations. */
+    status?: ProgressStatus;
+    size?: ProgressSize;
+    /** Thickness of the track. Overrides what `size` would give it. */
+    thickness?: number;
+    /** Shows the figure beside the bar, or inside the ring. */
+    showValue?: boolean;
+    /** Turns the figure into whatever the reader should see: `3 of 8`, `1.2 MB`. */
+    formatter?: (value: number, max: number) => string;
+    /**
+     * Work with no end in sight: the bar travels rather than fills, and reports
+     * nothing to a screen reader beyond the fact that it is busy.
+     */
+    indeterminate?: boolean;
+    /** Accessible name. Give one whenever there is no visible label beside it. */
+    ariaLabel?: string;
+}

package/dist/components/Rate/Rate.d.ts

@@ -18,7 +18,7 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     id: string;
     max: number;
     readonly: boolean;
-    allowHalf: boolean;
     showValue: boolean;
+    allowHalf: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/components/Result/Result.d.ts

@@ -0,0 +1,38 @@
+import { IconName } from '../Icon/types';
+import { ResultProps, ResultStatus } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        icon?: () => unknown;
+        title?: () => unknown;
+        subtitle?: () => unknown;
+        /** The way out: back to the list, try again, contact somebody. */
+        actions?: () => unknown;
+        /** Anything under the actions — a stack trace behind a disclosure, a reference. */
+        default?: () => unknown;
+    }> & {
+        icon?: () => unknown;
+        title?: () => unknown;
+        subtitle?: () => unknown;
+        /** The way out: back to the list, try again, contact somebody. */
+        actions?: () => unknown;
+        /** Anything under the actions — a stack trace behind a disclosure, a reference. */
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ResultProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ResultProps> & Readonly<{}>, {
+    title: string;
+    subtitle: string;
+    icon: IconName;
+    status: ResultStatus;
+}, {}, {}, {}, 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/Result/index.d.ts

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

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

@@ -0,0 +1,15 @@
+import { IconName } from '../Icon/types';
+/**
+ * What happened. The three numbers are the HTTP replies an admin panel actually
+ * shows a page for; the rest are outcomes of something the user just did.
+ */
+export type ResultStatus = 'success' | 'warning' | 'danger' | 'info' | '403' | '404' | '500';
+export interface ResultProps {
+    status?: ResultStatus;
+    /** The outcome in a few words: `Order placed`, `Page not found`. */
+    title?: string;
+    /** What it means, or what to do next. */
+    subtitle?: string;
+    /** Icon to draw instead of the one the status picks. */
+    icon?: IconName;
+}

package/dist/components/Segmented/Segmented.d.ts

@@ -0,0 +1,44 @@
+import { SegmentedOption, SegmentedProps, SegmentedValue } from './types';
+type __VLS_Props = SegmentedProps;
+type __VLS_PublicProps = {
+    modelValue?: SegmentedValue | undefined;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** A segment's contents, when a label and an icon are not enough. */
+        option?: (props: {
+            option: SegmentedOption;
+            selected: boolean;
+        }) => unknown;
+    }> & {
+        /** A segment's contents, when a label and an icon are not enough. */
+        option?: (props: {
+            option: SegmentedOption;
+            selected: boolean;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: SegmentedValue) => any;
+    "update:modelValue": (value: SegmentedValue | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: ((value: SegmentedValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: SegmentedValue | undefined) => any) | undefined;
+}>, {
+    size: import('../..').ControlSize;
+    disabled: boolean;
+    ariaLabel: string;
+    options: SegmentedOption[];
+    block: 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/Segmented/index.d.ts

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

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

@@ -0,0 +1,23 @@
+import { ControlSize } from '../../composables/useFormField';
+import { IconName } from '../Icon/types';
+export type SegmentedValue = string | number;
+export interface SegmentedOption {
+    label?: string;
+    value: SegmentedValue;
+    icon?: IconName;
+    disabled?: boolean;
+    /** Accessible name when the segment shows only an icon. */
+    ariaLabel?: string;
+}
+export interface SegmentedProps {
+    options?: SegmentedOption[];
+    size?: ControlSize;
+    /** Stretches to the width it is given, the segments sharing it equally. */
+    block?: boolean;
+    disabled?: boolean;
+    /** Accessible name for the group. */
+    ariaLabel?: string;
+}
+export interface SegmentedEmits {
+    change: [value: SegmentedValue];
+}

package/dist/components/SelectionArea/SelectionArea.d.ts

@@ -0,0 +1,48 @@
+import { SelectionAreaProps, SelectionAreaSlotProps, SelectionValue } from './types';
+type __VLS_Props = SelectionAreaProps;
+declare function selectAll(): void;
+declare function clear(): void;
+type __VLS_PublicProps = {
+    modelValue?: SelectionValue[];
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: (props: SelectionAreaSlotProps) => unknown;
+    }> & {
+        default?: (props: SelectionAreaSlotProps) => unknown;
+    };
+    refs: {
+        root: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    selectAll: typeof selectAll;
+    clear: typeof clear;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    start: () => any;
+    end: (value: SelectionValue[]) => any;
+    "update:modelValue": (value: SelectionValue[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onStart?: (() => any) | undefined;
+    onEnd?: ((value: SelectionValue[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: SelectionValue[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    match: import('./types').SelectionMatch;
+    threshold: number;
+    touch: boolean;
+    clickSelect: boolean;
+    edgeScroll: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: 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/SelectionArea/directive.d.ts

@@ -0,0 +1,19 @@
+import { ObjectDirective } from 'vue';
+import { SelectionValue } from './types';
+/** Marks an element as something a selection box can catch. */
+export declare const SELECTABLE = "data-wx-selectable";
+/**
+ * The value of a selectable element. Falls back to the attribute, so markup that is not
+ * written in Vue can say `data-wx-selectable="42"` and be caught the same way — as the
+ * string `'42'`, since that is all an attribute can hold.
+ */
+export declare function valueOf(el: Element): SelectionValue | undefined;
+/**
+ * `v-wx-select="item.id"` hands an element to the selection area around it.
+ *
+ * A directive rather than a component, because the element is already there — a card, a
+ * row, a list item — and wrapping every one of them in a box of ours would break the grid
+ * or table it sits in. It also keeps the value's type: an attribute could only carry the
+ * string `'42'`, and the selection would stop matching the numbers the model holds.
+ */
+export declare const vWxSelect: ObjectDirective<HTMLElement, SelectionValue>;

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

@@ -0,0 +1,3 @@
+export { default as WxSelectionArea } from './SelectionArea';
+export { vWxSelect, SELECTABLE } from './directive';
+export type * from './types';

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

@@ -0,0 +1,26 @@
+export type SelectionValue = string | number;
+export type SelectionMatch = 'intersect' | 'contain';
+export interface SelectionAreaProps {
+    /** Whether the box has to cover an item or merely touch it. */
+    match?: SelectionMatch;
+    /** How far the pointer travels before it is a drag rather than a click, in pixels. */
+    threshold?: number;
+    /** A click picks one item; a click on the background clears the selection. */
+    clickSelect?: boolean;
+    /** Drag with a finger too. Off, because on a touch screen a drag scrolls. */
+    touch?: boolean;
+    /** How near the scroller's edge the pointer scrolls it, in pixels. `0` never does. */
+    edgeScroll?: number;
+    disabled?: boolean;
+}
+export interface SelectionAreaEmits {
+    /** The pointer has moved past the threshold and a box is being drawn. */
+    start: [];
+    /** The drag is over. Carries the selection it ended with. */
+    end: [value: SelectionValue[]];
+}
+export interface SelectionAreaSlotProps {
+    selected: Set<SelectionValue>;
+    isSelected: (value: SelectionValue) => boolean;
+    selecting: boolean;
+}

package/dist/components/Skeleton/Skeleton.d.ts

@@ -0,0 +1,33 @@
+import { SkeletonProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** The real thing, once it has arrived. */
+        default?: () => unknown;
+        /** A placeholder shaped like the real thing, instead of the rows. */
+        template?: () => unknown;
+    }> & {
+        /** The real thing, once it has arrived. */
+        default?: () => unknown;
+        /** A placeholder shaped like the real thing, instead of the rows. */
+        template?: () => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkeletonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {
+    title: boolean;
+    loading: boolean;
+    delay: number;
+    rows: number;
+    animated: boolean;
+    avatar: 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/Skeleton/index.d.ts

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

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

@@ -0,0 +1,31 @@
+/** What shape the placeholder stands in for. */
+export type SkeletonVariant = 'text' | 'title' | 'circle' | 'square' | 'image' | 'button';
+export interface SkeletonProps {
+    /**
+     * Whether the placeholder is showing. Once it is off, the default slot is what
+     * renders — so the same markup covers both states and the caller writes one `v-if`
+     * fewer.
+     */
+    loading?: boolean;
+    /** How many lines of text to stand in for. The last one is drawn short. */
+    rows?: number;
+    /** Adds a circle beside the lines, for a row that begins with a face. */
+    avatar?: boolean;
+    /** Draws the first line heavier, as a heading. */
+    title?: boolean;
+    /** The shimmer. Off for anything that will be on screen for a long time. */
+    animated?: boolean;
+    /**
+     * How long the content may take before the placeholder appears, in milliseconds.
+     * A request that answers in 80ms should not flash a skeleton on the way.
+     */
+    delay?: number;
+}
+export interface SkeletonItemProps {
+    variant?: SkeletonVariant;
+    /** Any CSS length, or pixels as a number. */
+    width?: string | number;
+    height?: string | number;
+    /** Follows the enclosing `WxSkeleton` unless set here. */
+    animated?: boolean;
+}

package/dist/components/SkeletonItem/SkeletonItem.d.ts

@@ -0,0 +1,8 @@
+import { SkeletonItemProps } from '../Skeleton/types';
+declare const _default: import('vue').DefineComponent<SkeletonItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkeletonItemProps> & Readonly<{}>, {
+    variant: import('..').SkeletonVariant;
+    width: string | number;
+    height: string | number;
+    animated: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;

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

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

package/dist/components/Slider/Slider.d.ts

@@ -15,9 +15,9 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     disabled: boolean;
     ariaLabel: string;
     id: string;
+    max: number;
     range: boolean;
     min: number;
-    max: number;
     step: number;
     showValue: boolean;
     marks: Record<number, string>;