@webx-ui/core 0.8.0 → 0.10.0

package/dist/components/TreeSelect/TreeSelect.d.ts

@@ -0,0 +1,47 @@
+import { TreeNode } from '../Tree/types';
+import { TreeSelectProps, TreeSelectValue } 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 onChange?: ((value: TreeSelectValue, nodes: T[]) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: TreeSelectValue) => any) | undefined;
+        readonly onClose?: (() => any) | undefined;
+        readonly onOpen?: (() => any) | undefined;
+        readonly onClear?: (() => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onChange" | "onUpdate:modelValue" | "onOpen" | "onClose" | "onClear"> & ({
+        modelValue?: TreeSelectValue;
+    } & TreeSelectProps<T>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        /** One node in the panel. */
+        node?: (props: {
+            node: T;
+            depth: number;
+            expanded: boolean;
+            selected: boolean;
+        }) => unknown;
+        /** What the field shows instead of the labels. */
+        value?: (props: {
+            nodes: T[];
+        }) => unknown;
+    }> & {
+        /** One node in the panel. */
+        node?: (props: {
+            node: T;
+            depth: number;
+            expanded: boolean;
+            selected: boolean;
+        }) => unknown;
+        /** What the field shows instead of the labels. */
+        value?: (props: {
+            nodes: T[];
+        }) => unknown;
+    };
+    emit: (((evt: "change", value: TreeSelectValue, nodes: T[]) => void) & ((evt: "close") => void) & ((evt: "open") => void) & ((evt: "clear") => void)) & ((evt: "update:modelValue", value: TreeSelectValue) => 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/TreeSelect/index.d.ts

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

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

@@ -0,0 +1,76 @@
+import { ControlSize, ControlStatus } from '../../composables/useFormField';
+import { TreeKey, TreeNode } from '../Tree/types';
+export type { TreeKey, TreeNode };
+/** One key, several of them with `multiple`, or nothing chosen. */
+export type TreeSelectValue = TreeKey | TreeKey[] | null;
+export interface TreeSelectProps<T = TreeNode> {
+    /** The tree to choose from — the same shape `WxTree` takes. */
+    nodes?: T[];
+    /** Adds checkboxes and turns the model into an array. */
+    multiple?: boolean;
+    /**
+     * With `multiple`, a tick stays where it was made instead of running down into the
+     * children and up into the parent. The model then holds exactly what was ticked,
+     * which is usually what a form wants to send.
+     */
+    checkStrictly?: boolean;
+    /** 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 unchoosable. */
+    disabledKey?: string;
+    /** Field that says a node has no children to fetch. Only read when `lazy`. */
+    leafKey?: string;
+    /** Open every branch when the panel is first built. */
+    defaultExpandAll?: 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[]>;
+    /**
+     * The path to what is chosen — the ancestors and the node itself — for a tree that
+     * has not fetched it yet. A lazy field has no other way to name the value it holds,
+     * or to know which branches to open in order to show it. One path, or an array of
+     * them with `multiple`.
+     *
+     * A backend that knows the record knows its ancestors, so this is the same query the
+     * form already makes.
+     */
+    selectedPath?: T[] | T[][];
+    /** Adds the search field above the tree. */
+    filterable?: boolean;
+    filterPlaceholder?: string;
+    /**
+     * Shows the whole path in the field — `Engine / Pistons` — rather than the label
+     * alone. Worth it wherever the same name appears under two parents.
+     */
+    showPath?: boolean;
+    /** What goes between the steps of a path. */
+    separator?: string;
+    /** How tall the tree inside the panel may get before it scrolls. */
+    panelHeight?: number | string;
+    /** Shows a button that empties the selection. */
+    clearable?: boolean;
+    placeholder?: string;
+    /** Shown in the panel when there is nothing to choose from. */
+    emptyText?: string;
+    /** Render the panel in a portal so it escapes `overflow: hidden`. */
+    teleport?: boolean;
+    disabled?: boolean;
+    size?: ControlSize;
+    status?: ControlStatus;
+    id?: string;
+    name?: string;
+    /** Accessible label used when there is no visible `<label>`. */
+    ariaLabel?: string;
+}
+export interface TreeSelectEmits<T = TreeNode> {
+    /** The selection changed. The nodes come with it, since an id alone rarely is it. */
+    change: [value: TreeSelectValue, nodes: T[]];
+    clear: [];
+    open: [];
+    close: [];
+}

package/dist/components/Upload/Upload.d.ts

@@ -0,0 +1,74 @@
+import { UploadFile, UploadProps } from './types';
+type __VLS_Props = UploadProps;
+type __VLS_PublicProps = {
+    modelValue?: UploadFile[];
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Replaces the inside of the drop zone. */
+        default?: (props: {
+            open: () => void;
+            dragging: boolean;
+        }) => unknown;
+        /** Replaces the row a file is shown as. */
+        file?: (props: {
+            file: UploadFile;
+            remove: () => void;
+        }) => unknown;
+        /** Under the zone: a note about formats or sizes. */
+        footer?: () => unknown;
+    }> & {
+        /** Replaces the inside of the drop zone. */
+        default?: (props: {
+            open: () => void;
+            dragging: boolean;
+        }) => unknown;
+        /** Replaces the row a file is shown as. */
+        file?: (props: {
+            file: UploadFile;
+            remove: () => void;
+        }) => unknown;
+        /** Under the zone: a note about formats or sizes. */
+        footer?: () => unknown;
+    };
+    refs: {
+        input: HTMLInputElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: UploadFile[]) => any;
+    select: (file: UploadFile) => any;
+    add: (files: UploadFile[]) => any;
+    remove: (file: UploadFile) => any;
+    reject: (file: File, reason: "size" | "type" | "count" | "rejected") => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: UploadFile[]) => any) | undefined;
+    onSelect?: ((file: UploadFile) => any) | undefined;
+    onAdd?: ((files: UploadFile[]) => any) | undefined;
+    onRemove?: ((file: UploadFile) => any) | undefined;
+    onReject?: ((file: File, reason: "size" | "type" | "count" | "rejected") => any) | undefined;
+}>, {
+    multiple: boolean;
+    disabled: boolean;
+    max: number;
+    accept: string;
+    maxSize: number;
+    buttonOnly: boolean;
+    buttonText: string;
+    hint: string;
+    gallery: boolean;
+    removable: boolean;
+    beforeAdd: (file: File) => boolean | Promise<boolean>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    input: HTMLInputElement;
+}, 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/Upload/index.d.ts

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

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

@@ -0,0 +1,54 @@
+/** Where a file has got to. */
+export type UploadStatus = 'ready' | 'uploading' | 'done' | 'error';
+export interface UploadFile {
+    /** Stable across the file's whole life, including a retry. */
+    id: string;
+    name: string;
+    /** In bytes. `0` for a file that arrived as a URL rather than from disk. */
+    size: number;
+    type: string;
+    status: UploadStatus;
+    /** How far along, 0–100. Meaningful while `uploading`. */
+    progress: number;
+    /** What went wrong, for a file that failed. */
+    error?: string;
+    /** Where it ended up, once the caller knows. */
+    url?: string;
+    /** The file itself, for anything picked from disk. */
+    raw?: File;
+}
+export interface UploadProps {
+    /** What the file input accepts, e.g. `image/*,.pdf`. */
+    accept?: string;
+    multiple?: boolean;
+    /** Largest file, in bytes. Anything over it is refused before it is added. */
+    maxSize?: number;
+    /** Largest number of files. */
+    max?: number;
+    /** Drops the drop zone and leaves a button. */
+    buttonOnly?: boolean;
+    /** Label of the button. */
+    buttonText?: string;
+    /** The line inside the drop zone. */
+    hint?: string;
+    /** Shows each file as a thumbnail rather than a row. For pictures. */
+    gallery?: boolean;
+    disabled?: boolean;
+    /** Whether a file can be taken off the list once it is there. */
+    removable?: boolean;
+    /**
+     * Asked about every file before it joins the list. Return `false` — or a rejected
+     * promise — to refuse it. This is where a caller checks dimensions, or renames.
+     */
+    beforeAdd?: (file: File) => boolean | Promise<boolean>;
+}
+export interface UploadEmits {
+    /** Files that passed the checks and joined the list. */
+    add: [files: UploadFile[]];
+    /** A file was taken off the list. */
+    remove: [file: UploadFile];
+    /** A file was refused, and why. */
+    reject: [file: File, reason: 'size' | 'count' | 'type' | 'rejected'];
+    /** A file in the list was chosen — to preview it, usually. */
+    select: [file: UploadFile];
+}

package/dist/components/index.d.ts

@@ -2,9 +2,13 @@ export * from './Accordion';
 export * from './AccordionItem';
 export * from './Action';
 export * from './Actions';
+export * from './Affix';
 export * from './Alert';
 export * from './Aside';
 export * from './Autocomplete';
+export * from './Avatar';
+export * from './AvatarGroup';
+export * from './Backtop';
 export * from './Badge';
 export * from './Breadcrumb';
 export * from './BreadcrumbItem';
@@ -21,11 +25,14 @@ export * from './Countdown';
 export * from './DatePicker';
 export * from './DateRangePicker';
 export * from './DateTimePicker';
+export * from './Descriptions';
+export * from './DescriptionsItem';
 export * from './Dialog';
 export * from './Divider';
 export * from './Drawer';
 export * from './Dropdown';
 export * from './DropdownItem';
+export * from './Empty';
 export * from './EntityCard';
 export * from './Footer';
 export * from './Form';
@@ -33,29 +40,41 @@ export * from './FormItem';
 export * from './Header';
 export * from './Heading';
 export * from './Icon';
+export * from './Image';
 export * from './Indicator';
 export * from './Input';
 export * from './InputNumber';
 export * from './Kanban';
 export * from './Link';
 export * from './ListDetail';
+export * from './Loading';
 export * from './Main';
 export * from './Menu';
 export * from './MenuGroup';
 export * from './MenuItem';
 export * from './Pagination';
+export * from './Popconfirm';
 export * from './Popover';
+export * from './Progress';
 export * from './Prose';
 export * from './Radio';
 export * from './RadioGroup';
 export * from './Rate';
+export * from './Result';
 export * from './RichText';
 export * from './Row';
 export * from './Scrollbar';
+export * from './Segmented';
 export * from './Select';
+export * from './SelectionArea';
+export * from './Skeleton';
+export * from './SkeletonItem';
 export * from './Slider';
+export * from './SortableList';
 export * from './Space';
 export * from './Statistic';
+export * from './Step';
+export * from './Steps';
 export * from './Submenu';
 export * from './Switch';
 export * from './Tab';
@@ -67,3 +86,9 @@ export * from './Textarea';
 export * from './Timeline';
 export * from './TimelineItem';
 export * from './TimePicker';
+export * from './Toaster';
+export * from './Tooltip';
+export * from './Transfer';
+export * from './Tree';
+export * from './TreeSelect';
+export * from './Upload';

package/dist/composables/confirm.d.ts

@@ -0,0 +1,23 @@
+import { ButtonType } from '../components/Button/types';
+export interface ConfirmOptions {
+    /** The question, as the heading. Defaults to "Are you sure?" */
+    title?: string;
+    /** What is at stake, under the question. */
+    message?: string;
+    confirmText?: string;
+    cancelText?: string;
+    /** Colour of the confirming button. `danger` for anything that destroys something. */
+    tone?: ButtonType;
+    width?: number | string;
+}
+/**
+ * Asks, and answers `true` or `false`.
+ *
+ * ```ts
+ * if (await confirm('Delete this product?')) remove(product)
+ * ```
+ *
+ * It never rejects. A question that throws when the answer is no turns every call site
+ * into a `try` block, and a forgotten `catch` into an unhandled rejection.
+ */
+export declare function confirm(message?: string | ConfirmOptions, options?: ConfirmOptions): Promise<boolean>;

package/dist/composables/useModal.d.ts

@@ -0,0 +1,68 @@
+import { App, AppContext, Component, InjectionKey, Ref } from 'vue';
+/** What a component opened from code can do about itself. */
+export interface ModalHandle<T = unknown> {
+    /** `false` in a component that is being used declaratively. */
+    isModal: boolean;
+    /** Bind it to the panel: `<wx-dialog v-model:open="open">`. */
+    open: Ref<boolean>;
+    /** Settles the promise with a value, and closes. */
+    resolve: (value: T) => void;
+    /** Settles it with nothing, and closes. */
+    dismiss: () => void;
+}
+export interface ModalOptions {
+    /** Props for the component. */
+    props?: Record<string, unknown>;
+    /** Slots for it, as render functions. */
+    slots?: Record<string, (...args: unknown[]) => unknown>;
+    /** Events that settle the promise with their payload. Default: `resolve`. */
+    resolveOn?: string | string[];
+    /** Events that settle it with nothing. Default: `cancel` and `close`. */
+    dismissOn?: string | string[];
+    /** Where to mount. Default: a div at the end of `<body>`. */
+    container?: HTMLElement;
+    /** The app whose plugins and provides the component should see. */
+    appContext?: AppContext;
+    /** How long the closing animation is given before the node is taken away, in ms. */
+    duration?: number;
+}
+export interface ModalPromise<T> extends Promise<T | undefined> {
+    /** Closes it from outside — a route change, a timeout, a second thought. */
+    close: (value?: T) => void;
+}
+export declare const modalKey: InjectionKey<ModalHandle>;
+export declare function connectModals(app: App): void;
+/**
+ * Mounts a component outside the app and hands back a promise for its answer.
+ *
+ * ```ts
+ * const product = await openModal<Product>(ProductBrowser, {
+ *   props: { multiple: false },
+ *   resolveOn: 'select',
+ * })
+ * ```
+ *
+ * The promise settles the moment the answer is known and the node is taken away once the
+ * closing animation has had its time — so the caller is never waiting on an animation, and
+ * the panel is never cut off mid-fade.
+ */
+export declare function openModal<T = unknown>(component: Component, options?: ModalOptions): ModalPromise<T>;
+/**
+ * Wraps a component in a function that opens it — the shape a browser or a picker is
+ * reached by everywhere else in an app.
+ *
+ * ```ts
+ * export const productBrowser = createModal<Product, ProductBrowserProps>(ProductBrowser, {
+ *   resolveOn: 'select',
+ * })
+ *
+ * const product = await productBrowser({ multiple: false })
+ * ```
+ */
+export declare function createModal<T = unknown, P extends Record<string, unknown> = Record<string, never>>(component: Component, defaults?: ModalOptions): (props?: P, options?: ModalOptions) => ModalPromise<T>;
+/**
+ * The handle of the modal a component is being shown in. Outside one it answers all the
+ * same, with `isModal: false` and calls that do nothing — so a component can be written
+ * once and used both ways.
+ */
+export declare function useModal<T = unknown>(): ModalHandle<T>;

package/dist/composables/useToast.d.ts

@@ -0,0 +1,66 @@
+import { DeepReadonly } from 'vue';
+import { IconName } from '../components/Icon/types';
+export type ToastType = 'default' | 'success' | 'warning' | 'danger' | 'info';
+export interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+export interface ToastOptions {
+    /** A headline. Without one the toast is a single line — a message rather than a card. */
+    title?: string;
+    /** The message. This is what a one-line toast says. */
+    description?: string;
+    type?: ToastType;
+    /**
+     * How long it stays, in milliseconds. `0` keeps it until it is dismissed, which is
+     * what an error the reader has to act on wants.
+     */
+    duration?: number;
+    /** Adds a ×. On by default for anything that does not leave on its own. */
+    closable?: boolean;
+    /** Glyph to draw instead of the one the type picks; `false` drops it. */
+    icon?: IconName | false;
+    /** One thing to do about it: Undo, Retry, View. */
+    action?: ToastAction;
+}
+export interface ToastRecord extends ToastOptions {
+    id: number;
+    /** Bound to the panel; set to false to start it leaving. */
+    open: boolean;
+}
+export interface ToastHandle {
+    id: number;
+    dismiss: () => void;
+}
+/** What the `WxToaster` renders. Nothing else should be writing to it. */
+export declare function toastQueue(): DeepReadonly<ToastRecord[]>;
+/** Starts a toast leaving. It is taken off the queue once it has gone. */
+export declare function dismissToast(id: number): void;
+/** Takes a toast off the queue for good — called when its animation has finished. */
+export declare function removeToast(id: number): void;
+/** Clears everything on screen at once. */
+export declare function clearToasts(): void;
+export interface ToastApi {
+    (message: string | ToastOptions, options?: ToastOptions): ToastHandle;
+    success: (message: string | ToastOptions, options?: ToastOptions) => ToastHandle;
+    warning: (message: string | ToastOptions, options?: ToastOptions) => ToastHandle;
+    danger: (message: string | ToastOptions, options?: ToastOptions) => ToastHandle;
+    info: (message: string | ToastOptions, options?: ToastOptions) => ToastHandle;
+    dismiss: (id: number) => void;
+    clear: () => void;
+}
+declare const api: ToastApi;
+/**
+ * Raises a toast from anywhere.
+ *
+ * ```ts
+ * const toast = useToast()
+ * toast.success('Saved')
+ * toast.danger({ title: 'Could not save', description: response.message })
+ * ```
+ *
+ * The same object is importable as `toast` for code that is not in a component at
+ * all — an interceptor, say. Put one `<wx-toaster />` on the page to show them.
+ */
+export declare function useToast(): ToastApi;
+export { api as toast };

package/dist/composables/useTreeNodes.d.ts

@@ -0,0 +1,96 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+export type TreeKey = string | number;
+/** Where a dragged node lands relative to the one it was dropped on. */
+export type TreeDropZone = 'before' | 'after' | 'inside';
+/**
+ * How to read one node. Everything else here works through these four, which is what
+ * lets the same machinery drive a tree of its own and a table whose rows happen to
+ * nest: neither has to agree with the other on what a node looks like.
+ */
+export interface TreeAccessors<T> {
+    key: (node: T, path: number[]) => TreeKey;
+    children: (node: T) => T[] | undefined;
+    /** Called when a branch that had no `children` array needs one. */
+    setChildren: (node: T, children: T[]) => void;
+    label?: (node: T) => string;
+    disabled?: (node: T) => boolean;
+    /** Says a node has nothing under it — only needed with `lazy`, where an empty
+     * `children` cannot tell "not loaded yet" from "nothing there". */
+    leaf?: (node: T) => boolean;
+}
+/** One node and everything about where it sits, kept for the whole tree. */
+export interface TreeEntry<T> {
+    node: T;
+    key: TreeKey;
+    depth: number;
+    /** The array this node currently lives in — moving is a splice on it. */
+    siblings: T[];
+    index: number;
+    parent: T | null;
+    parentKey: TreeKey | null;
+    children: T[];
+}
+/** A node as the screen shows it: visible, in order, at a depth. */
+export interface TreeRow<T> extends TreeEntry<T> {
+    expandable: boolean;
+    expanded: boolean;
+    loading: boolean;
+    disabled: boolean;
+    /** Matched the filter itself, as opposed to merely leading to a match. */
+    matched: boolean;
+}
+export interface UseTreeNodesOptions<T> {
+    /**
+     * The tree. A getter or a plain array is enough for a tree that is only read; a
+     * `ref` is what a tree that can be rearranged wants, since a move splices the array
+     * the caller is holding.
+     */
+    nodes: MaybeRefOrGetter<T[]>;
+    accessors: TreeAccessors<T>;
+    /** Keys of the open branches. Owned by the caller, so `v-model:expanded` works. */
+    expanded: Ref<TreeKey[]>;
+    /** Only branches matching this, and the branches leading to them, are shown. */
+    filter?: MaybeRefOrGetter<string | undefined>;
+    /** Opening a branch closes the others at its level. */
+    accordion?: MaybeRefOrGetter<boolean>;
+    /** Children arrive when a branch opens. Requires `load`. */
+    lazy?: MaybeRefOrGetter<boolean>;
+    load?: (node: T) => T[] | Promise<T[]>;
+    /** Vetoes a move before it happens. */
+    allowDrop?: (drag: T, drop: T, zone: TreeDropZone) => boolean;
+}
+/**
+ * The parts of a tree that have nothing to do with how it looks: what is where, what is
+ * open, what a filter leaves standing, and what a move does to the arrays underneath.
+ */
+export declare function useTreeNodes<T>(options: UseTreeNodesOptions<T>): {
+    rows: import('vue').ComputedRef<TreeRow<T>[]>;
+    entries: import('vue').ComputedRef<Map<TreeKey, TreeEntry<T>>>;
+    entry: (key: TreeKey) => TreeEntry<T> | undefined;
+    keyOf: (node: T, path?: number[]) => TreeKey;
+    filtered: import('vue').ComputedRef<{
+        keep: Set<TreeKey>;
+        matched: Set<TreeKey>;
+    } | null>;
+    isExpanded: (key: TreeKey) => boolean;
+    expand: (key: TreeKey) => Promise<void>;
+    collapse: (key: TreeKey) => void;
+    toggle: (key: TreeKey) => void | Promise<void>;
+    expandAll: () => void;
+    collapseAll: () => void;
+    reveal: (key: TreeKey) => void;
+    openPath: (keys: TreeKey[]) => Promise<boolean>;
+    ancestors: (key: TreeKey) => TreeEntry<T>[];
+    path: (key: TreeKey) => TreeEntry<T>[];
+    descendants: (key: TreeKey) => TreeEntry<T>[];
+    isAncestorOf: (key: TreeKey, other: TreeKey) => boolean;
+    canDrop: (dragKey: TreeKey, dropKey: TreeKey, zone: TreeDropZone) => boolean;
+    move: (dragKey: TreeKey, dropKey: TreeKey, zone: TreeDropZone) => {
+        node: T;
+        parent: T | null;
+        siblings: T[];
+        index: number;
+    } | null;
+    loading: Ref<Set<TreeKey> & Omit<Set<TreeKey>, keyof Set<any>>, Set<TreeKey> | (Set<TreeKey> & Omit<Set<TreeKey>, keyof Set<any>>)>;
+};
+export type UseTreeNodes<T> = ReturnType<typeof useTreeNodes<T>>;

package/dist/index.d.ts

@@ -3,4 +3,7 @@ export { WebxUI, type WebxUiOptions } from './plugin';
 export type { ControlSize, ControlStatus, ValidationErrors } from './composables/useFormField';
 export { useControlAttrs, type ControlAttrs } from './composables/useControlAttrs';
 export { useElementWidth } from './composables/useElementWidth';
+export { useToast, toast, toastQueue, dismissToast, removeToast, clearToasts, type ToastApi, type ToastHandle, type ToastOptions, type ToastRecord, type ToastType, type ToastAction, } from './composables/useToast';
+export { openModal, createModal, useModal, connectModals, modalKey, type ModalHandle, type ModalOptions, type ModalPromise, } from './composables/useModal';
+export { confirm, type ConfirmOptions } from './composables/confirm';
 export { useResponsiveShell, shellLayoutFor, type ResponsiveShell, type ResponsiveShellOptions, type ShellLayout, } from './composables/useResponsiveShell';