@webx-ui/core 0.8.0 → 0.10.0

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

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

package/dist/components/Steps/Steps.d.ts

@@ -0,0 +1,31 @@
+import { StepsProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => unknown;
+    }> & {
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLOListElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<StepsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (index: number) => any;
+}, string, import('vue').PublicProps, Readonly<StepsProps> & Readonly<{
+    onChange?: ((index: number) => any) | undefined;
+}>, {
+    size: import('./types').StepsSize;
+    ariaLabel: string;
+    error: boolean;
+    current: number;
+    direction: import('./types').StepsDirection;
+    clickable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLOListElement>;
+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/Steps/context.d.ts

@@ -0,0 +1,5 @@
+import { InjectionKey } from 'vue';
+import { StepsContext } from './types';
+export declare const stepsKey: InjectionKey<StepsContext>;
+/** A step outside a sequence is one step, on its own, and still renders. */
+export declare function useSteps(): StepsContext;

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

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

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

@@ -0,0 +1,44 @@
+import { IconName } from '../Icon/types';
+export type StepsDirection = 'horizontal' | 'vertical';
+export type StepsSize = 'sm' | 'md';
+/** Where a step stands relative to the one the reader is on. */
+export type StepState = 'done' | 'current' | 'todo' | 'error';
+export interface StepsProps {
+    /** Which step the reader is on, counting from zero. */
+    current?: number;
+    direction?: StepsDirection;
+    size?: StepsSize;
+    /** Marks the current step as gone wrong, without moving off it. */
+    error?: boolean;
+    /**
+     * Lets a finished step be clicked to go back to it. Going forward is never
+     * offered: the steps ahead are the ones that have not been filled in.
+     */
+    clickable?: boolean;
+    /** Accessible name of the sequence. */
+    ariaLabel?: string;
+}
+export interface StepsEmits {
+    /** A step was chosen. Only fires for steps that are behind the current one. */
+    change: [index: number];
+}
+export interface StepProps {
+    /** What this step is. */
+    title?: string;
+    /** What it involves, in a few words. */
+    description?: string;
+    /** Icon instead of the number. */
+    icon?: IconName;
+}
+/** What `WxSteps` hands down to each step. */
+export interface StepsContext {
+    register: (id: symbol) => void;
+    unregister: (id: symbol) => void;
+    indexOf: (id: symbol) => number;
+    stateOf: (index: number) => StepState;
+    choose: (index: number) => void;
+    direction: StepsDirection;
+    size: StepsSize;
+    clickable: boolean;
+    total: number;
+}

package/dist/components/Table/Table.d.ts

@@ -12,8 +12,9 @@ declare const _default: <T extends TableRow = TableRow>(__VLS_props: NonNullable
         readonly "onSort-change"?: ((sort: TableSort | null) => any) | undefined;
         readonly "onSelection-change"?: ((keys: RowKey[], rows: T[]) => any) | undefined;
         readonly "onExpand-change"?: ((keys: RowKey[], rows: T[]) => any) | undefined;
+        readonly "onNode-drop"?: ((event: import('./types').TableNodeDropEvent<T>) => any) | undefined;
         readonly "onState-change"?: ((state: TableState) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSearch" | "onUpdate:page" | "onUpdate:perPage" | "onUpdate:selected" | "onUpdate:expanded" | "onUpdate:sort" | "onUpdate:search" | "onRow-click" | "onSort-change" | "onSelection-change" | "onExpand-change" | "onState-change"> & ({
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSearch" | "onUpdate:page" | "onUpdate:perPage" | "onUpdate:selected" | "onUpdate:expanded" | "onUpdate:sort" | "onUpdate:search" | "onRow-click" | "onSort-change" | "onSelection-change" | "onExpand-change" | "onNode-drop" | "onState-change"> & ({
         selected?: RowKey[];
         expanded?: RowKey[];
         sort?: TableSort | null;
@@ -70,7 +71,7 @@ declare const _default: <T extends TableRow = TableRow>(__VLS_props: NonNullable
             index: number;
         }) => unknown;
     };
-    emit: (((evt: "search", term: string) => void) & ((evt: "row-click", row: T, index: number, event: MouseEvent) => void) & ((evt: "sort-change", sort: TableSort | null) => void) & ((evt: "selection-change", keys: RowKey[], rows: T[]) => void) & ((evt: "expand-change", keys: RowKey[], rows: T[]) => void) & ((evt: "state-change", state: TableState) => void)) & (((evt: "update:page", value: number) => void) & ((evt: "update:perPage", value: number) => void) & ((evt: "update:selected", value: RowKey[]) => void) & ((evt: "update:expanded", value: RowKey[]) => void) & ((evt: "update:sort", value: TableSort | null) => void) & ((evt: "update:search", value: string) => void));
+    emit: (((evt: "search", term: string) => void) & ((evt: "row-click", row: T, index: number, event: MouseEvent) => void) & ((evt: "sort-change", sort: TableSort | null) => void) & ((evt: "selection-change", keys: RowKey[], rows: T[]) => void) & ((evt: "expand-change", keys: RowKey[], rows: T[]) => void) & ((evt: "node-drop", event: import('./types').TableNodeDropEvent<T>) => void) & ((evt: "state-change", state: TableState) => void)) & (((evt: "update:page", value: number) => void) & ((evt: "update:perPage", value: number) => void) & ((evt: "update:selected", value: RowKey[]) => void) & ((evt: "update:expanded", value: RowKey[]) => void) & ((evt: "update:sort", value: TableSort | null) => void) & ((evt: "update:search", value: string) => void));
 }>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

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

@@ -1,4 +1,6 @@
 import { ControlSize } from '../../composables/useFormField';
+import { TreeDropZone } from '../../composables/useTreeNodes';
+export type { TreeDropZone };
 /**
  * A page as Laravel's `->paginate()` serialises it. Taken as it arrives, with the
  * snake_case keys intact — renaming them in every controller is work the table can
@@ -36,9 +38,10 @@ export interface TableColumn<T = TableRow> {
     /** Adds a sort control to the heading. The table reports, it does not reorder. */
     sortable?: boolean;
     /**
-     * Pins the column to an edge while the rest scrolls sideways. A pinned column needs
-     * a `width`: the offsets of the ones behind it are worked out from the declared
-     * widths, and a column of unknown width cannot say where the next one starts.
+     * Pins the column to an edge while the rest scrolls sideways. Give it a `width` as
+     * well: the table measures where each pinned column comes to rest, but the declared
+     * width is what the offsets fall back on before the first measurement — and what
+     * decides how wide the column is in the first place.
      */
     fixed?: 'left' | 'right';
     /** Turns the raw value into the text of the cell. */
@@ -62,6 +65,57 @@ export interface TableSummaryRow {
     strong?: boolean;
     class?: string;
 }
+/**
+ * Turns the rows into a tree: the first column keeps the disclosure and the
+ * indentation, every other column is still a column.
+ *
+ * A tree is a structure, and the two things a table does to a flat list destroy it —
+ * so in this mode `sortable` columns are drawn without their control and `pagination`
+ * is off. Ordering a tree is what dragging is for, and a page of it would cut branches
+ * in half.
+ */
+export interface TableTreeOptions<T = TableRow> {
+    /** Field holding the children of a row. */
+    childrenKey?: string;
+    /**
+     * Field that says a row has children before any have been fetched — Laravel's
+     * `withCount('children')` under its own name, or a boolean of your own. Without it a
+     * lazy table cannot tell a leaf from a branch nobody has opened yet.
+     */
+    hasChildrenKey?: string;
+    /** Children arrive when a row is opened. Requires `load`. */
+    lazy?: boolean;
+    /** Fetches the children of one row. */
+    load?: (row: T) => T[] | Promise<T[]>;
+    /** Open every branch that is already loaded, once, on the first render. */
+    defaultExpandAll?: boolean;
+    /** How far one level sits from the next, in pixels. */
+    indent?: number;
+    /** Rows can be picked up and dropped before, after or inside another. */
+    draggable?: boolean;
+    /** Rows this returns `false` for cannot be picked up. */
+    allowDrag?: (row: T) => boolean;
+    /** Vetoes a landing spot before anything moves. */
+    allowDrop?: (drag: T, drop: T, zone: TreeDropZone) => boolean;
+    /**
+     * How long a row dragged over a closed branch waits before that branch opens.
+     * Dropping into a branch you cannot see the inside of is a guess; this turns the
+     * guess into a look. Zero switches it off.
+     */
+    springDelay?: number;
+}
+/** What a finished move says: the row, where it went, and how it got there. */
+export interface TableNodeDropEvent<T = TableRow> {
+    row: T;
+    /** The row it was dropped on. */
+    target: T;
+    zone: TreeDropZone;
+    /** The row it now hangs from — `null` at the top level. */
+    parent: T | null;
+    /** Its position among its new siblings. */
+    index: number;
+    via: 'pointer' | 'keyboard';
+}
 /** Everything the table asks the backend for, in one object. */
 export interface TableState {
     page: number;
@@ -123,6 +177,8 @@ export interface TableProps<T = TableRow> {
     maxHeight?: string | number;
     /** Extra class per row, for status colouring and the like. */
     rowClass?: (row: T, index: number) => string | undefined;
+    /** Draws the rows as a tree. See {@link TableTreeOptions}. */
+    tree?: TableTreeOptions<T>;
     /** Fixes the column widths instead of letting the content decide. */
     layout?: 'auto' | 'fixed';
     ariaLabel?: string;
@@ -132,6 +188,8 @@ export interface TableEmits<T = TableRow> {
     'sort-change': [sort: TableSort | null];
     'selection-change': [keys: RowKey[], rows: T[]];
     'expand-change': [keys: RowKey[], rows: T[]];
+    /** A row was moved in tree mode. The rows have already been rearranged. */
+    'node-drop': [event: TableNodeDropEvent<T>];
     search: [term: string];
     /**
      * Everything the backend needs, together. Fires once on mount — with whatever

package/dist/components/Textarea/Textarea.d.ts

@@ -27,8 +27,8 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
     ariaLabel: string;
     status: import('../..').ControlStatus;
     id: string;
-    readonly: boolean;
     resize: "none" | "vertical" | "both";
+    readonly: boolean;
     maxlength: number;
     showCount: boolean;
     rows: number;

package/dist/components/Toaster/Toaster.d.ts

@@ -0,0 +1,9 @@
+import { ToasterProps } from './types';
+declare const _default: import('vue').DefineComponent<ToasterProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ToasterProps> & Readonly<{}>, {
+    label: string;
+    width: number | string;
+    max: number;
+    placement: import('./types').ToasterPlacement;
+    hotkey: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

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

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

@@ -0,0 +1,16 @@
+/** Which corner — or edge — the toasts stack in. */
+export type ToasterPlacement = 'top-start' | 'top-center' | 'top-end' | 'bottom-start' | 'bottom-center' | 'bottom-end';
+export interface ToasterProps {
+    placement?: ToasterPlacement;
+    /** Width of a toast: a number in pixels, or any CSS length. */
+    width?: number | string;
+    /** Accessible name of the region the toasts land in. */
+    label?: string;
+    /**
+     * How many are shown at once. The rest wait their turn rather than covering the
+     * screen — a hundred failed requests is one problem, not a hundred notifications.
+     */
+    max?: number;
+    /** Key that dismisses everything on screen, e.g. `F8`. */
+    hotkey?: string[];
+}

package/dist/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,44 @@
+import { TooltipProps } from './types';
+type __VLS_Props = TooltipProps;
+type __VLS_PublicProps = {
+    'open'?: boolean | undefined;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** The control the tip belongs to. Exactly one element. */
+        default?: () => unknown;
+        /** The tip itself, when the text is not enough. */
+        content?: () => unknown;
+    }> & {
+        /** The control the tip belongs to. Exactly one element. */
+        default?: () => unknown;
+        /** The tip itself, when the text is not enough. */
+        content?: () => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean | undefined) => any) | undefined;
+}>, {
+    disabled: boolean;
+    content: string;
+    side: import('./types').TooltipSide;
+    align: import('./types').TooltipAlign;
+    offset: number;
+    teleport: boolean;
+    delay: number;
+    maxWidth: number | string;
+    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/Tooltip/index.d.ts

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

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

@@ -0,0 +1,25 @@
+export type TooltipSide = 'top' | 'right' | 'bottom' | 'left';
+export type TooltipAlign = 'start' | 'center' | 'end';
+export interface TooltipProps {
+    /** The text. Use the `content` slot for anything richer. */
+    content?: string;
+    /** Which side of the trigger it prefers; it flips when there is no room. */
+    side?: TooltipSide;
+    align?: TooltipAlign;
+    /** Distance from the trigger, in pixels. */
+    offset?: number;
+    /**
+     * How long the pointer has to rest before the tip appears, in milliseconds. The
+     * first tip in a group waits; the ones after it come at once, because by then the
+     * reader has said what they are doing.
+     */
+    delay?: number;
+    /** Draws the little pointer at the trigger. */
+    arrow?: boolean;
+    /** Largest width the tip takes before it wraps. */
+    maxWidth?: number | string;
+    /** Nothing opens. For a tip whose trigger is temporarily meaningless. */
+    disabled?: boolean;
+    /** Render the tip in a portal so it escapes `overflow: hidden`. */
+    teleport?: boolean;
+}

package/dist/components/Transfer/Transfer.d.ts

@@ -0,0 +1,57 @@
+import { TransferItem, TransferProps, TransferSide, TransferValue } from './types';
+type __VLS_Props = TransferProps;
+type __VLS_PublicProps = {
+    modelValue?: TransferValue[];
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** One row, on either side. */
+        item?: (props: {
+            item: TransferItem;
+            side: TransferSide;
+        }) => unknown;
+        /** Shown in a panel with nothing in it. */
+        empty?: (props: {
+            side: TransferSide;
+        }) => unknown;
+    }> & {
+        /** One row, on either side. */
+        item?: (props: {
+            item: TransferItem;
+            side: TransferSide;
+        }) => unknown;
+        /** Shown in a panel with nothing in it. */
+        empty?: (props: {
+            side: TransferSide;
+        }) => 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: (change: import('./types').TransferChange) => any;
+    "update:modelValue": (value: TransferValue[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: ((change: import('./types').TransferChange) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: TransferValue[]) => any) | undefined;
+}>, {
+    size: import('../..').ControlSize;
+    disabled: boolean;
+    emptyText: string;
+    height: number | string;
+    items: TransferItem[];
+    searchable: boolean;
+    searchPlaceholder: string;
+    titles: [string, string];
+    toRightLabel: string;
+    toLeftLabel: 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/Transfer/index.d.ts

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

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

@@ -0,0 +1,40 @@
+import { ControlSize } from '../../composables/useFormField';
+export type TransferValue = string | number;
+export type TransferSide = 'left' | 'right';
+export interface TransferItem {
+    value: TransferValue;
+    /** What is read on the row. Falls back to the value. */
+    label?: string;
+    /** A second line under the label. */
+    description?: string;
+    /** Cannot be moved, from either side. */
+    disabled?: boolean;
+}
+export interface TransferProps {
+    /** Everything there is to choose from, both panels together. */
+    items?: TransferItem[];
+    /** Headings of the two panels. */
+    titles?: [string, string];
+    /** A search field over each panel. */
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    /** Height of a list: a number in pixels, or any CSS length. */
+    height?: number | string;
+    /** Shown in a panel with nothing in it. */
+    emptyText?: string;
+    size?: ControlSize;
+    disabled?: boolean;
+    /** Accessible names for the two buttons. */
+    toRightLabel?: string;
+    toLeftLabel?: string;
+}
+export interface TransferChange {
+    /** What moved, in the order it was shown. */
+    values: TransferValue[];
+    /** Which panel it moved to. */
+    to: TransferSide;
+}
+export interface TransferEmits {
+    /** Something moved. The model has already been rewritten. */
+    change: [change: TransferChange];
+}

package/dist/components/Tree/Tree.d.ts

@@ -0,0 +1,79 @@
+import { TreeKey } from '../../composables/useTreeNodes';
+import { TreeNode, TreeProps } from './types';
+declare const _default: <T extends TreeNode>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+        readonly onCheck?: ((keys: TreeKey[], detail: {
+            node: T;
+            checked: boolean;
+        }) => any) | undefined;
+        readonly onSelect?: ((node: T | null, key: TreeKey | null) => any) | undefined;
+        readonly onCollapse?: ((node: T) => any) | undefined;
+        readonly onDrop?: ((event: import('./types').TreeDropEvent<T>) => any) | undefined;
+        readonly onExpand?: ((node: T) => any) | undefined;
+        readonly "onUpdate:selected"?: ((value: TreeKey | null) => any) | undefined;
+        readonly "onUpdate:expanded"?: ((value: TreeKey[]) => any) | undefined;
+        readonly "onUpdate:checked"?: ((value: TreeKey[]) => any) | undefined;
+        readonly "onNode-click"?: ((node: T, event: MouseEvent) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onDrop" | "onSelect" | "onCollapse" | "onExpand" | "onUpdate:selected" | "onUpdate:expanded" | "onCheck" | "onUpdate:checked" | "onNode-click"> & ({
+        modelValue?: T[];
+        expanded?: TreeKey[];
+        selected?: TreeKey | null;
+        checked?: TreeKey[];
+    } & TreeProps<T>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        /** Opens every branch on the way to a node. */
+        reveal: (key: TreeKey) => void;
+        /**
+         * Opens a named path one level at a time, waiting for each lazy level before asking
+         * for the next — the way to reach a node the tree has not fetched yet.
+         */
+        openPath: (keys: TreeKey[]) => Promise<boolean>;
+        expandAll: () => void;
+        collapseAll: () => void;
+        /** The node itself and everything above it — a breadcrumb of the tree. */
+        path: (key: TreeKey) => T[];
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        /** One node's label. Without it the tree reads `labelKey` and highlights the filter. */
+        default?: (props: {
+            node: T;
+            depth: number;
+            expanded: boolean;
+            selected: boolean;
+        }) => unknown;
+        /** The end of a row, where the buttons that act on it go. */
+        actions?: (props: {
+            node: T;
+            depth: number;
+        }) => unknown;
+        /** Shown in place of an empty tree. */
+        empty?: () => unknown;
+    }> & {
+        /** One node's label. Without it the tree reads `labelKey` and highlights the filter. */
+        default?: (props: {
+            node: T;
+            depth: number;
+            expanded: boolean;
+            selected: boolean;
+        }) => unknown;
+        /** The end of a row, where the buttons that act on it go. */
+        actions?: (props: {
+            node: T;
+            depth: number;
+        }) => unknown;
+        /** Shown in place of an empty tree. */
+        empty?: () => unknown;
+    };
+    emit: (((evt: "check", keys: TreeKey[], detail: {
+        node: T;
+        checked: boolean;
+    }) => void) & ((evt: "select", node: T | null, key: TreeKey | null) => void) & ((evt: "collapse", node: T) => void) & ((evt: "drop", event: import('./types').TreeDropEvent<T>) => void) & ((evt: "expand", node: T) => void) & ((evt: "node-click", node: T, event: MouseEvent) => void)) & (((evt: "update:modelValue", value: T[]) => void) & ((evt: "update:selected", value: TreeKey | null) => void) & ((evt: "update:expanded", value: TreeKey[]) => void) & ((evt: "update:checked", value: TreeKey[]) => void));
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

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

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

@@ -0,0 +1,99 @@
+import { TreeDropZone, TreeKey } from '../../composables/useTreeNodes';
+export type { TreeDropZone, TreeKey };
+export type TreeSize = 'sm' | 'md';
+/**
+ * A node as the tree hopes to find it. Every field is optional and every name is a prop
+ * away from being something else, so a record straight out of a Laravel controller —
+ * `{ id, title, children }` — is a tree without a `map` over it first.
+ */
+export interface TreeNode {
+    id?: TreeKey;
+    key?: TreeKey;
+    label?: string;
+    children?: TreeNode[];
+    disabled?: boolean;
+    /**
+     * Says this node has nothing under it. Only needed with `lazy`, where an empty
+     * `children` cannot tell "not loaded yet" from "nothing there".
+     */
+    leaf?: boolean;
+    [field: string]: unknown;
+}
+/** What a finished move says: the node, where it went, and how it got there. */
+export interface TreeDropEvent<T = TreeNode> {
+    node: T;
+    /** The node it was dropped on. */
+    target: T;
+    zone: TreeDropZone;
+    /** The node it now hangs from — `null` at the top level. */
+    parent: T | null;
+    /** Its position among its new siblings. */
+    index: number;
+    via: 'pointer' | 'keyboard';
+}
+export interface TreeProps<T = TreeNode> {
+    /** Field holding the identity of a node. */
+    nodeKey?: string;
+    /** Field holding the text of a node. */
+    labelKey?: string;
+    /** Field holding the array of children. */
+    childrenKey?: string;
+    /** Field that, when true, makes a node unselectable and unmovable. */
+    disabledKey?: string;
+    /** Field that says a node has no children to fetch. Only read when `lazy`. */
+    leafKey?: string;
+    /** Expand every branch once, on the first render. */
+    defaultExpandAll?: boolean;
+    /** Opening a branch closes the others at its level. */
+    accordion?: boolean;
+    /** Clicking a label opens the branch as well as selecting it. */
+    expandOnClick?: boolean;
+    /** Adds a checkbox to every node. */
+    checkable?: boolean;
+    /**
+     * Checking a branch leaves its children alone. Off — the default — a branch follows
+     * its children and its children follow it, which is what a permission tree wants.
+     */
+    checkStrictly?: boolean;
+    /** Rows can be picked up and dropped before, after or inside another. */
+    draggable?: boolean;
+    /** Nodes this returns `false` for cannot be picked up. */
+    allowDrag?: (node: T) => boolean;
+    /** Vetoes a landing spot — say, to keep a page out of the root. */
+    allowDrop?: (drag: T, drop: T, zone: TreeDropZone) => boolean;
+    /** Children are fetched when a branch first opens. Requires `load`. */
+    lazy?: boolean;
+    /** Fetches the children of one node. */
+    load?: (node: T) => T[] | Promise<T[]>;
+    /**
+     * Shows only the nodes whose label contains this, together with the branches that
+     * lead to them — which are opened for as long as the term stands.
+     */
+    filter?: string;
+    /** Draws the guide lines that connect a child to its parent. */
+    showLines?: boolean;
+    /** How far one level sits from the next, in pixels. */
+    indent?: number;
+    size?: TreeSize;
+    /** Shown when there is nothing to draw. */
+    emptyText?: string;
+    /** What the drag handle is called, before the name of the node it holds. */
+    dragLabel?: string;
+    /** Accessible name for the tree. */
+    ariaLabel?: string;
+}
+export interface TreeEmits<T = TreeNode> {
+    /** A node was clicked — before anything was decided about selection. */
+    'node-click': [node: T, event: MouseEvent];
+    /** The selected node changed. */
+    select: [node: T | null, key: TreeKey | null];
+    /** A checkbox changed. The keys are every checked node, branches included. */
+    check: [keys: TreeKey[], detail: {
+        node: T;
+        checked: boolean;
+    }];
+    expand: [node: T];
+    collapse: [node: T];
+    /** A node was moved. The tree has already been rearranged. */
+    drop: [event: TreeDropEvent<T>];
+}