@synopackageland/ui 0.4.2 → 0.5.3

package/dist/components/composite/form/types.d.ts

@@ -0,0 +1,50 @@
+import { FormFieldHandle } from './context';
+export type ValidateTrigger = 'blur' | 'change';
+export type ValidateStatus = '' | 'success' | 'error' | 'warning' | 'validating';
+/** How a failed rule message is surfaced: a floating hint or text below the field. */
+export type ValidateMessageDisplayMode = 'popup' | 'text';
+/** FormItem-level value: `'form'` inherits the enclosing form's mode. */
+export type FormItemValidateMessageDisplayMode = ValidateMessageDisplayMode | 'form';
+export type FormDirection = 'horizontal' | 'vertical';
+export type FormSpacing = 'none' | 'dense' | 'compact' | 'regular' | 'relaxed' | number | 'auto';
+export type FormRuleType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'email' | 'url' | 'date';
+export type FormRuleCallback = (error?: Error | string | void) => void;
+/**
+ * One validation rule. A rule may be asynchronous: return a promise from
+ * `validator`, reject it, or resolve it with an error message; the callback
+ * form still works and wins when it is called.
+ */
+export type FormRule = {
+    /** Marks the value as mandatory. `false` is a present value, not an empty one. */
+    required?: boolean;
+    /** Message used when this rule fails; built-in defaults are English. */
+    message?: string;
+    /** When the rule runs on its own; falls back to FormItem's `defaultValidateTrigger`. Explicit `validate()` calls always run every rule. */
+    trigger?: ValidateTrigger | ValidateTrigger[];
+    /** Custom check. Called with `(rule, value, callback)` like async-validator. */
+    validator?: (rule: FormRule, value: unknown, callback: FormRuleCallback) => unknown;
+    /** Promise-flavoured custom check; `validator` wins when both are set. */
+    asyncValidator?: (rule: FormRule, value: unknown, callback: FormRuleCallback) => unknown;
+    pattern?: RegExp;
+    type?: FormRuleType;
+    /** Minimum length (string/array) or value (number/date). */
+    min?: number;
+    /** Maximum length (string/array) or value (number/date). */
+    max?: number;
+    /** Exact length (string/array). */
+    len?: number;
+    /** Allowed values. */
+    enum?: readonly unknown[];
+    /** Normalises the value before the built-in checks run. */
+    transform?: (value: unknown) => unknown;
+};
+export type FormRules = Record<string, FormRule | FormRule[]>;
+export type FormValidateError = {
+    error: string | undefined;
+    field: FormFieldHandle;
+};
+export type FormValidatedResult = {
+    valid: boolean;
+    errResults: FormValidateError[];
+};
+export type { FormFieldHandle };

package/dist/components/composite/message-box/MessageBox.vue.d.ts

@@ -0,0 +1,34 @@
+import { MessageBoxKind, MessageBoxOptions } from './types';
+/**
+ * One app-local message box. It is fully controlled: it never closes itself,
+ * it emits `settle` with the button id (or typed value) the user chose and the
+ * host removes it. See `types.ts` for the awaited API.
+ */
+type __VLS_Props = {
+    open?: boolean;
+    kind: MessageBoxKind;
+    title?: string;
+    message?: string;
+    options?: MessageBoxOptions;
+    phrase?: string;
+    progress?: {
+        percent: number;
+        info?: string;
+        percentText?: string;
+    };
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    settle: (value: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSettle?: ((value: unknown) => any) | undefined;
+}>, {
+    progress: {
+        percent: number;
+        info?: string;
+        percentText?: string;
+    };
+    open: boolean;
+    options: MessageBoxOptions;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/composite/message-box/MessageBoxProvider.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<{}, import('./types').MessageBox, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/composite/message-box/controller.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from 'vue';
+import { MessageBox, MessageBoxRequest } from './types';
+export type MessageBoxHost = {
+    box: MessageBox;
+    requests: Ref<MessageBoxRequest[]>;
+    settle: (id: number, value: unknown) => void;
+    dispose: () => void;
+};
+export type { LostChangeResult, MessageBox, MessageBoxButtonId, MessageBoxHandler, MessageBoxKind, MessageBoxOptions, MessageBoxPromptOptions, MessageBoxTextResult, MessageBoxTone, MessageBoxVerify, ProgressResult, } from './types';
+/**
+ * Owns the queue of active app-local message boxes. `MessageBoxProvider` renders
+ * the queue and calls `settle` with the button id or typed value a box resolved.
+ */
+export declare function createMessageBoxHost(): MessageBoxHost;
+/** The awaitable dialog API. Call it in `setup()`; a `MessageBoxProvider` must be an ancestor. */
+export declare function useDialog(): MessageBox;
+/** Alias of `useDialog()` that names the message-box family explicitly. */
+export declare function useMessageBox(): MessageBox;
+/** Registers `host.dispose` for the component that owns the host. */
+export declare function useMessageBoxHost(): MessageBoxHost;

package/dist/components/composite/message-box/types.d.ts

@@ -0,0 +1,97 @@
+import { InjectionKey } from 'vue';
+/**
+ * Fixed message-box flows. Every flow is an app-local modal dialog; none of
+ * them creates a DSM window or a draggable frame.
+ */
+export type MessageBoxKind = 'alert' | 'confirm' | 'confirmDelete' | 'confirmLostChange' | 'prompt' | 'password' | 'progress' | 'wait';
+/**
+ * Result of a box without a custom handler. It is a button id, never a
+ * boolean: `if (result)` is always true, compare with `=== 'confirm'`.
+ */
+export type MessageBoxButtonId = 'confirm' | 'cancel' | 'leftCustom';
+/** Discriminated result of the unsaved-change flow. */
+export type LostChangeResult = 'save' | 'dont_save' | 'cancel';
+/** Discriminated result of the progress / wait flows. */
+export type ProgressResult = 'closed' | 'cancel';
+/**
+ * Discriminated result of the prompt / password flows. The typed text and the
+ * dismissal are different shapes, so typing the literal text `cancel` is never
+ * mistaken for a dismissed box.
+ */
+export type MessageBoxTextResult = {
+    status: 'submitted';
+    value: string;
+} | {
+    status: 'cancel';
+};
+export type MessageBoxTone = 'info' | 'warning' | 'danger';
+/**
+ * Prompt verification. Returning / resolving `false` (or throwing / rejecting)
+ * keeps the box open and shows `invalidMessage`.
+ */
+export type MessageBoxVerify = (value: string) => unknown | Promise<unknown>;
+export type MessageBoxPromptOptions = {
+    /** `false` hides the label. Defaults to `false` for `prompt()` and `"Password:"` for `password()`. */
+    label?: string | false;
+    placeholder?: string;
+    type?: 'text' | 'password';
+    verify?: MessageBoxVerify;
+    invalidMessage?: string;
+};
+/**
+ * Custom button handler. Return `false` to keep the box open; return any other
+ * value to resolve the awaiting call with that value; return `undefined` to
+ * fall back to the button id. A pending handler puts the box in a busy state,
+ * so a second activation is ignored until it settles.
+ */
+export type MessageBoxHandler = () => unknown | Promise<unknown>;
+export type MessageBoxOptions = {
+    width?: string;
+    tone?: MessageBoxTone;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    /** Shows a leading custom button that resolves to `'leftCustom'`. */
+    leftCustomLabel?: string;
+    prompt?: MessageBoxPromptOptions;
+    doConfirm?: MessageBoxHandler;
+    doCancel?: MessageBoxHandler;
+    doLeftCustom?: MessageBoxHandler;
+    onClose?: (result: unknown) => void;
+};
+/**
+ * Awaited API returned by `useDialog()` / `MessageBoxProvider`. Every method
+ * opens one app-local modal and resolves when the user settles it.
+ */
+export type MessageBox = {
+    alert: (title: string, message?: string, options?: MessageBoxOptions) => Promise<MessageBoxButtonId>;
+    confirm: (title: string, message?: string, options?: MessageBoxOptions) => Promise<MessageBoxButtonId>;
+    confirmDelete: (title: string, message?: string, options?: MessageBoxOptions) => Promise<MessageBoxButtonId>;
+    confirmLostChange: (title?: string, message?: string, options?: MessageBoxOptions) => Promise<LostChangeResult>;
+    /** Resolves `{ status: 'submitted', value }`, or `{ status: 'cancel' }` when dismissed. */
+    prompt: (message: string, phrase?: string, options?: MessageBoxOptions) => Promise<MessageBoxTextResult>;
+    /** Resolves `{ status: 'submitted', value }`, or `{ status: 'cancel' }` when dismissed. */
+    password: (title?: string, message?: string, options?: MessageBoxOptions) => Promise<MessageBoxTextResult>;
+    progress: (title: string, percent: number, info?: string, percentText?: string, options?: MessageBoxOptions) => Promise<ProgressResult>;
+    wait: (title: string, info?: string, options?: MessageBoxOptions) => Promise<ProgressResult>;
+    /** Updates the newest open progress / wait box; a no-op when there is none. */
+    updateProgress: (title: string, percent: number, info?: string, percentText?: string, options?: MessageBoxOptions) => void;
+    /** Closes the newest open progress / wait box (or the newest box), resolving it with `'closed'`. */
+    onClose: () => void;
+    /** Compatibility shim: the controller is a single long-lived instance, so this returns itself. */
+    getMsgBox: () => MessageBox;
+};
+/** One active box handed from the controller to `MessageBoxProvider`. */
+export type MessageBoxRequest = {
+    id: number;
+    kind: MessageBoxKind;
+    title?: string;
+    message?: string;
+    phrase?: string;
+    progress: {
+        percent: number;
+        info?: string;
+        percentText?: string;
+    };
+    options: MessageBoxOptions;
+};
+export declare const messageBoxKey: InjectionKey<MessageBox>;

package/dist/components/composite/overflow-list/OverflowList.vue.d.ts

@@ -0,0 +1,40 @@
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<{
+        items?: T[];
+        collapseDirection?: "start" | "end";
+        minVisibleItemsNum?: number;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        refresh: () => Promise<void>;
+        visibleCount: import('vue').Ref<number, number>;
+        overflowItems: import('vue').ComputedRef<T[]>;
+        visibleItems: import('vue').ComputedRef<T[]>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            item: T;
+            visibleIndex: number;
+            visibleItems: T[];
+            overflowItems: T[];
+        }) => unknown;
+        'overflow-item'?: (props: {
+            visibleItems: T[];
+            overflowItems: T[];
+        }) => unknown;
+        'overflow-start-anchor'?: () => unknown;
+        'overflow-end-anchor'?: () => unknown;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/composite/overflow-list/OverflowListItem.vue.d.ts

@@ -0,0 +1,18 @@
+type __VLS_Props = {
+    visible?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    visible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/composite/overflow-toolbar/OverflowToolbar.vue.d.ts

@@ -0,0 +1,46 @@
+import { OverflowToolbarItem, OverflowToolbarMenuEntry, OverflowToolbarMoreMenu, OverflowToolbarMoreState } from './types';
+/**
+ * An item-driven toolbar: anything that does not fit moves into a right-hand
+ * More menu, including the submenu entries of an overflowed dropdown item.
+ */
+type __VLS_Props = {
+    items?: OverflowToolbarItem[];
+    /** Items kept in the row even when the row is too narrow for them. */
+    minVisibleItemsNum?: number;
+    moreMenu?: OverflowToolbarMoreMenu;
+    /** Custom More label, e.g. `({ overflowItems }) => `More (${overflowItems.length})``. */
+    getMoreButtonText?: (state: OverflowToolbarMoreState) => string;
+};
+declare var __VLS_1: {}, __VLS_4: string, __VLS_5: {
+    item: OverflowToolbarItem;
+}, __VLS_35: {}, __VLS_37: {}, __VLS_124: {
+    item: OverflowToolbarItem;
+};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_4>]?: (props: typeof __VLS_5) => any;
+} & {
+    'overflow-start-anchor'?: (props: typeof __VLS_1) => any;
+} & {
+    'overflow-end-anchor'?: (props: typeof __VLS_35) => any;
+} & {
+    right?: (props: typeof __VLS_37) => any;
+} & {
+    'overflow-item'?: (props: typeof __VLS_124) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clickItem: (item: OverflowToolbarMenuEntry | OverflowToolbarItem) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClickItem?: ((item: OverflowToolbarMenuEntry | OverflowToolbarItem) => any) | undefined;
+}>, {
+    items: OverflowToolbarItem[];
+    minVisibleItemsNum: number;
+    moreMenu: OverflowToolbarMoreMenu;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/composite/overflow-toolbar/overflow.d.ts

@@ -0,0 +1,25 @@
+/** The gap between two toolbar items; the More button reserves one more. */
+export declare const ITEM_GAP = 4;
+export type OverflowFitInput = {
+    /** Measured widths of every item, in row order. */
+    widths: number[];
+    /** The row's own width, which the absolutely positioned More button never changes. */
+    availableWidth: number;
+    /** Measured width of the widest More button the current label can produce. */
+    moreWidth: number;
+    gap: number;
+    minVisibleItems: number;
+};
+export type OverflowFit = {
+    visibleCount: number;
+    needsMore: boolean;
+};
+/**
+ * How many items fit next to the More button. Pure arithmetic over measured
+ * widths, so the toolbar only has to feed it numbers and can be tested without
+ * a layout engine.
+ *
+ * `More` is reserved as soon as the row cannot hold everything, and at least
+ * `minVisibleItems` items stay out of it even when they do not fit.
+ */
+export declare function computeOverflowFit({ widths, availableWidth, moreWidth, gap, minVisibleItems }: OverflowFitInput): OverflowFit;

package/dist/components/composite/overflow-toolbar/types.d.ts

@@ -0,0 +1,27 @@
+/** An entry of an item's dropdown, or of the overflowed item's submenu. */
+export type OverflowToolbarMenuEntry = {
+    id: string;
+    title?: string;
+    /** `divider` renders a separator and carries no action. */
+    type?: 'item' | 'divider';
+    disabled?: boolean;
+};
+export type OverflowToolbarItem = OverflowToolbarMenuEntry & {
+    /** Entries of this item's dropdown; they become a submenu once it overflows. */
+    menuItems?: OverflowToolbarMenuEntry[];
+    /** Name of a slot that renders this item in the toolbar row. */
+    slot?: string;
+    /** Extra props forwarded to the item's button. */
+    bind?: Record<string, unknown>;
+};
+/** Options for the More dropdown. `align` defaults to `end`, against the right edge. */
+export type OverflowToolbarMoreMenu = {
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+};
+export type OverflowToolbarMoreState = {
+    visibleItems: OverflowToolbarItem[];
+    overflowItems: OverflowToolbarItem[];
+};
+export type OverflowToolbarMoreText = (state: OverflowToolbarMoreState) => string;

package/dist/components/composite/settings-section/SettingsSection.vue.d.ts

@@ -2,13 +2,28 @@ type __VLS_Props = {
     title: string;
     collapsible?: boolean;
     defaultOpen?: boolean;
+    /** Bound with `v-model:open` for controlled collapse. */
+    open?: boolean;
 };
-declare var __VLS_6: {};
+declare var __VLS_6: {}, __VLS_8: {}, __VLS_10: {}, __VLS_12: {}, __VLS_14: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_6) => any;
+    title?: (props: typeof __VLS_6) => any;
+} & {
+    actions?: (props: typeof __VLS_8) => any;
+} & {
+    title?: (props: typeof __VLS_10) => any;
+} & {
+    actions?: (props: typeof __VLS_12) => any;
+} & {
+    default?: (props: typeof __VLS_14) => any;
 };
-declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
     defaultOpen: boolean;
+    open: boolean;
     collapsible: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/composite/tree-view/TreeView.vue.d.ts

@@ -1,38 +1,90 @@
-import { Component } from 'vue';
-export type TreeNode = {
-    id: string;
-    label: string;
-    children?: TreeNode[];
-    disabled?: boolean;
-    icon?: Component;
-    data?: unknown;
-};
+import { TreeViewCheckPayload, TreeViewDraggableConfig, TreeViewPosition, TreeNode } from './types';
+export type { TreeNode, TreeViewCheckPayload, TreeViewDraggableConfig, TreeViewPosition, TreeViewReorder } from './types';
 type __VLS_Props = {
     nodes: TreeNode[];
     modelValue?: string | string[];
     expanded?: string[];
     multiple?: boolean;
     showIcons?: boolean;
+    /** Show a leaf-based checkbox per node, with parent tri-state roll-up. */
+    checkable?: boolean;
+    checkedKeys?: string[];
+    defaultCheckedKeys?: string[];
+    /** Drag nodes to reorder, nest or move them next to a target. */
+    draggable?: boolean | TreeViewDraggableConfig;
+    /** Fetch children the first time a node without children is expanded. */
+    loadChildren?: (node: TreeNode) => Promise<TreeNode[] | undefined>;
+    /** Localise the expand/collapse control. */
+    expandLabel?: (node: TreeNode, expanded: boolean) => string;
 };
-declare var __VLS_27: {
+declare function nodeById(id: string): TreeNode | undefined;
+declare function getCheckedNodes(includeHalf?: boolean): TreeNode[];
+/** Moves a node among its siblings; used by the Alt+Arrow keys and the exposed API. */
+declare function moveSiblingBy(node: TreeNode, delta: number): void;
+declare function moveNode(sourceId: string, targetId: string, position: TreeViewPosition): void;
+declare var __VLS_63: {
     node: TreeNode;
     selected: boolean;
 };
 type __VLS_Slots = {} & {
-    trailing?: (props: typeof __VLS_27) => any;
+    trailing?: (props: typeof __VLS_63) => any;
 };
-declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    getNodes: () => TreeNode[];
+    nodeById: typeof nodeById;
+    getCheckedNodes: typeof getCheckedNodes;
+    moveNode: typeof moveNode;
+    moveSiblingBy: typeof moveSiblingBy;
+    expandNode: (id: string) => void;
+    collapseNode: (id: string) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     select: (node: TreeNode) => any;
     "update:modelValue": (value: string | string[] | undefined) => any;
+    "update:checkedKeys": (value: string[]) => any;
+    load: (payload: {
+        node: TreeNode;
+        children: TreeNode[];
+    }) => any;
+    reorder: (payload: {
+        node: TreeNode;
+        target: TreeNode;
+        position: TreeViewPosition;
+        nodes: TreeNode[];
+    }) => any;
+    expand: (node: TreeNode) => any;
     "update:expanded": (value: string[]) => any;
+    "update:nodes": (value: TreeNode[]) => any;
+    check: (payload: TreeViewCheckPayload) => any;
+    collapse: (node: TreeNode) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSelect?: ((node: TreeNode) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string | string[] | undefined) => any) | undefined;
+    "onUpdate:checkedKeys"?: ((value: string[]) => any) | undefined;
+    onLoad?: ((payload: {
+        node: TreeNode;
+        children: TreeNode[];
+    }) => any) | undefined;
+    onReorder?: ((payload: {
+        node: TreeNode;
+        target: TreeNode;
+        position: TreeViewPosition;
+        nodes: TreeNode[];
+    }) => any) | undefined;
+    onExpand?: ((node: TreeNode) => any) | undefined;
     "onUpdate:expanded"?: ((value: string[]) => any) | undefined;
+    "onUpdate:nodes"?: ((value: TreeNode[]) => any) | undefined;
+    onCheck?: ((payload: TreeViewCheckPayload) => any) | undefined;
+    onCollapse?: ((node: TreeNode) => any) | undefined;
 }>, {
     multiple: boolean;
+    checkedKeys: string[];
+    draggable: boolean | TreeViewDraggableConfig;
     expanded: string[];
     showIcons: boolean;
+    checkable: boolean;
+    defaultCheckedKeys: string[];
+    loadChildren: (node: TreeNode) => Promise<TreeNode[] | undefined>;
+    expandLabel: (node: TreeNode, expanded: boolean) => string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/composite/tree-view/treeUtils.d.ts

@@ -0,0 +1,15 @@
+import { TreeNode, TreeViewPosition } from './types';
+export declare function cloneTree(nodes: TreeNode[]): TreeNode[];
+export declare function findNode(nodes: TreeNode[], id: string): TreeNode | undefined;
+export declare function flattenNodes(nodes: TreeNode[]): TreeNode[];
+export declare function containsId(node: TreeNode, id: string): boolean;
+/** Ids of the enabled leaves below (or at) a node; disabled subtrees are skipped. */
+export declare function enabledLeafIds(node: TreeNode): string[];
+/** The sibling array that holds `id`, anywhere in the tree, or `undefined`. */
+export declare function parentList(nodes: TreeNode[], id: string): TreeNode[] | undefined;
+/** A copy of `nodes` with `sourceId` moved next to or inside `targetId`. */
+export declare function moveNode(nodes: TreeNode[], sourceId: string, targetId: string, position: TreeViewPosition): TreeNode[];
+/** Moves a node one sibling up (`delta < 0`) or down. */
+export declare function moveSibling(nodes: TreeNode[], id: string, delta: number): TreeNode[];
+/** A copy of `nodes` with the children of `id` replaced. */
+export declare function setChildren(nodes: TreeNode[], id: string, children: TreeNode[]): TreeNode[];

package/dist/components/composite/tree-view/types.d.ts

@@ -0,0 +1,38 @@
+import { Component } from 'vue';
+export type TreeNode = {
+    id: string;
+    label: string;
+    children?: TreeNode[];
+    disabled?: boolean;
+    icon?: Component;
+    data?: unknown;
+    /** Marks a real leaf; `loadChildren` is never called for it. */
+    isLeaf?: boolean;
+    /** Reject drops that would nest other nodes inside this one. */
+    canAppend?: boolean;
+    /** Set `false` to keep this node from being dragged. */
+    draggable?: boolean;
+};
+/** Where a dragged node lands relative to the drop target. */
+export type TreeViewPosition = 'top' | 'bottom' | 'inner';
+export type TreeViewDraggableConfig = {
+    /** `append-only` only allows dropping inside a node. */
+    type?: 'full' | 'append-only';
+    canDrag?: (node: TreeNode) => boolean;
+    canDrop?: (info: {
+        node: TreeNode;
+        target: TreeNode;
+        position: TreeViewPosition;
+    }) => boolean;
+};
+export type TreeViewReorder = {
+    node: TreeNode;
+    target: TreeNode;
+    position: TreeViewPosition;
+    nodes: TreeNode[];
+};
+export type TreeViewCheckPayload = {
+    node: TreeNode;
+    checked: boolean;
+    keys: string[];
+};

package/dist/components/composite/virtual-list/VirtualList.vue.d.ts

@@ -0,0 +1,44 @@
+import { StyleValue } from 'vue';
+import { ScrollBehaviorOption, ScrollToPositionOptions } from '../../primitives/scrollbar/types';
+export type VirtualItem<T = unknown> = {
+    data: T;
+    index: number | string;
+};
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<{
+        items?: VirtualItem<T>[];
+        keyField?: string;
+        minSize?: number;
+        willResize?: boolean;
+        bufferSize?: number;
+        disabled?: boolean;
+        viewStyle?: StyleValue;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        scrollTo: (options: ScrollToPositionOptions) => void;
+        ensureVisible: (key: string | number, behavior?: ScrollBehaviorOption) => boolean;
+        ensureIndexVisible: (index: number, behavior?: ScrollBehaviorOption) => boolean;
+        refresh: () => Promise<void>;
+        getScrollEl: () => HTMLElement | null;
+        totalSize: import('vue').ComputedRef<number>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            item: T;
+            index: number | string;
+        }) => unknown;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};