@synopackageland/ui 0.4.2 → 0.5.4

package/dist/components/composite/data-grid/DataGrid.vue.d.ts

@@ -13,10 +13,85 @@ export type DataGridColumn = {
     sortable?: boolean;
     /** Overrides the grid's `resizable` for this column. */
     resizable?: boolean;
+    /** Cell slots of an editable column get `editing`, `startEdit`, `stopEdit` and `update`. */
+    editable?: boolean;
     compare?: (a: unknown, b: unknown, rowA: Record<string, unknown>, rowB: Record<string, unknown>) => number;
 };
 export type DataGridColumnWidths = Record<string, number>;
-export type { DataGridLabels };
+export type DataGridGroup = {
+    /** Row field whose value identifies the group. */
+    field: string;
+    /** Group header text; defaults to the field value. */
+    label?: (value: unknown, rows: Record<string, unknown>[]) => string;
+    /** Groups start expanded unless this is `false`. */
+    defaultExpanded?: boolean;
+    /** Group order; defaults to the order groups first appear in the sorted rows. */
+    compare?: (a: unknown, b: unknown) => number;
+};
+export type DataGridExpandable = {
+    /** `row` toggles on double click as well; `cell` needs the chevron button only. */
+    type?: 'row' | 'cell';
+    /** Slot name of the expanded content; defaults to `expand`. */
+    slot?: string;
+};
+export type DataGridDraggable = {
+    /** Column key that shows the drag handle; without it a trailing handle column is added. */
+    pivotColumn?: string;
+    /** Reject drops that would leave the source group. */
+    withinGroup?: boolean;
+};
+export type DataGridReorder = {
+    rows: Record<string, unknown>[];
+    key: string;
+    from: number;
+    to: number;
+};
+export type DataGridCellUpdate = {
+    row: Record<string, unknown>;
+    column: DataGridColumn;
+    key: string;
+    value: unknown;
+    previous: unknown;
+};
+export type DataGridAdapter = {
+    expandRow: (key: string) => void;
+    collapseRow: (key: string) => void;
+    expandAllRows: () => void;
+    collapseAllRows: () => void;
+    expandAllGroups: () => void;
+    collapseAllGroups: () => void;
+    moveRowUp: (row: Record<string, unknown>) => void;
+    moveRowDown: (row: Record<string, unknown>) => void;
+};
+export type DataGridCellSlotProps = {
+    row: Record<string, unknown>;
+    value: unknown;
+    column: DataGridColumn;
+    index: number;
+    expanded: boolean;
+    editing: boolean;
+    startEdit: () => void;
+    stopEdit: () => void;
+    toggleExpand: () => void;
+    update: (value: unknown) => void;
+};
+export type DataGridGroupSlotProps = {
+    group: string;
+    label: string;
+    rows: Record<string, unknown>[];
+    category: {
+        key: string;
+        keys: string[];
+    };
+    expanded: boolean;
+    toggle: () => void;
+};
+export type DataGridExpandSlotProps = {
+    row: Record<string, unknown>;
+    index: number;
+};
+export type { DataGridLabels } from './labels';
+export type { ResolvedDataGridLabels } from './labels';
 type __VLS_Props = {
     columns: DataGridColumn[];
     rows: Record<string, unknown>[];
@@ -50,71 +125,121 @@ type __VLS_Props = {
     labels?: Partial<DataGridLabels>;
     /** @deprecated Use `labels.empty`. */
     emptyText?: string;
+    /** Split the visible rows into collapsible groups keyed by a row field. */
+    group?: DataGridGroup | null;
+    /** Show a per-row disclosure with the `expand` slot (or `expandable.slot`). */
+    expandable?: DataGridExpandable | null;
+    /** Bind to control which rows are expanded; leave unset and the grid tracks them. */
+    expandedKeys?: string[];
+    defaultExpandedKeys?: string[];
+    /** Row reordering with drag and drop plus keyboard support. */
+    draggable?: boolean | DataGridDraggable;
 };
-declare var __VLS_15: `header-${string}`, __VLS_16: {
-    column: DataGridColumn;
-}, __VLS_28: {}, __VLS_38: `cell-${string}`, __VLS_39: {
-    row: Record<string, unknown>;
-    value: unknown;
-    column: DataGridColumn;
-    index: number;
-}, __VLS_41: {
-    total: number;
-    page: number;
-    pageCount: number;
-};
-type __VLS_Slots = {} & {
-    [K in NonNullable<typeof __VLS_15>]?: (props: typeof __VLS_16) => any;
-} & {
-    [K in NonNullable<typeof __VLS_38>]?: (props: typeof __VLS_39) => any;
-} & {
-    empty?: (props: typeof __VLS_28) => any;
-} & {
-    footer?: (props: typeof __VLS_41) => any;
+type __VLS_Slots = {
+    empty?: (props: Record<string, never>) => unknown;
+    'group-title'?: (props: DataGridGroupSlotProps) => unknown;
+    footer?: (props: {
+        total: number;
+        page: number;
+        pageCount: number;
+    }) => unknown;
+    expand?: (props: DataGridExpandSlotProps) => unknown;
+    [name: `header-${string}`]: (props: {
+        column: DataGridColumn;
+    }) => unknown;
+    [name: `cell-${string}`]: (props: DataGridCellSlotProps) => unknown;
 };
-declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    expandRow: (key: string) => void;
+    collapseRow: (key: string) => void;
+    expandAllRows: () => void;
+    collapseAllRows: () => void;
+    expandAllGroups: () => void;
+    collapseAllGroups: () => void;
+    moveRowUp: (row: Record<string, unknown>) => void;
+    moveRowDown: (row: Record<string, unknown>) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     refresh: () => any;
     "update:sort": (value: DataGridSort | null) => any;
     "update:selectedKeys": (value: string[]) => any;
     "update:page": (value: number) => any;
     "update:columnWidths": (value: DataGridColumnWidths) => any;
+    "update:rows": (value: Record<string, unknown>[]) => any;
+    "update:expandedKeys": (value: string[]) => any;
     columnResize: (value: {
         key: string;
         width: number;
     }) => any;
     rowClick: (row: Record<string, unknown>) => any;
     rowDblclick: (row: Record<string, unknown>) => any;
+    rowExpand: (key: string) => any;
+    rowCollapse: (key: string) => any;
+    groupToggle: (groupKey: string, expanded: boolean) => any;
+    reorder: (value: DataGridReorder) => any;
+    cellEditStart: (value: {
+        row: Record<string, unknown>;
+        column: DataGridColumn;
+        key: string;
+    }) => any;
+    cellEditEnd: (value: {
+        row: Record<string, unknown>;
+        column: DataGridColumn;
+        key: string;
+    }) => any;
+    cellUpdate: (value: DataGridCellUpdate) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onRefresh?: (() => any) | undefined;
     "onUpdate:sort"?: ((value: DataGridSort | null) => any) | undefined;
     "onUpdate:selectedKeys"?: ((value: string[]) => any) | undefined;
     "onUpdate:page"?: ((value: number) => any) | undefined;
     "onUpdate:columnWidths"?: ((value: DataGridColumnWidths) => any) | undefined;
+    "onUpdate:rows"?: ((value: Record<string, unknown>[]) => any) | undefined;
+    "onUpdate:expandedKeys"?: ((value: string[]) => any) | undefined;
     onColumnResize?: ((value: {
         key: string;
         width: number;
     }) => any) | undefined;
     onRowClick?: ((row: Record<string, unknown>) => any) | undefined;
     onRowDblclick?: ((row: Record<string, unknown>) => any) | undefined;
+    onRowExpand?: ((key: string) => any) | undefined;
+    onRowCollapse?: ((key: string) => any) | undefined;
+    onGroupToggle?: ((groupKey: string, expanded: boolean) => any) | undefined;
+    onReorder?: ((value: DataGridReorder) => any) | undefined;
+    onCellEditStart?: ((value: {
+        row: Record<string, unknown>;
+        column: DataGridColumn;
+        key: string;
+    }) => any) | undefined;
+    onCellEditEnd?: ((value: {
+        row: Record<string, unknown>;
+        column: DataGridColumn;
+        key: string;
+    }) => any) | undefined;
+    onCellUpdate?: ((value: DataGridCellUpdate) => any) | undefined;
 }>, {
     footer: boolean;
     sort: DataGridSort | null;
     loading: boolean;
+    group: DataGridGroup | null;
+    loadingText: string;
+    page: number;
+    pageSize: number;
     rowKey: string;
     defaultSort: DataGridSort | null;
     selectedKeys: string[];
     selectable: boolean;
     selectOnRowClick: boolean;
-    page: number;
-    pageSize: number;
     localSort: boolean;
     localPagination: boolean;
-    loadingText: string;
     loadingRows: number;
     stickyHeader: boolean;
     resizable: boolean;
     refreshable: boolean;
     refreshing: boolean;
+    expandable: DataGridExpandable | null;
+    expandedKeys: string[];
+    defaultExpandedKeys: string[];
+    draggable: boolean | DataGridDraggable;
 }, {}, {}, {}, 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/data-grid/labels.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Text overrides for the grid chrome. The three row-operation labels were added
+ * after the first release and stay optional so an existing external
+ * `DataGridLabels` object literal keeps compiling; the grid merges the defaults in.
+ */
 export type DataGridLabels = {
     empty: string;
     items: (count: number) => string;
@@ -8,5 +13,14 @@ export type DataGridLabels = {
     selectAll: string;
     selectRow: (key: string) => string;
     resizeColumn: (label: string) => string;
+    expandRow?: (key: string) => string;
+    collapseRow?: (key: string) => string;
+    reorderRow?: (key: string) => string;
 };
-export declare const defaultDataGridLabels: DataGridLabels;
+/** `DataGridLabels` after the defaults were merged in: every label is present. */
+export type ResolvedDataGridLabels = DataGridLabels & {
+    expandRow: (key: string) => string;
+    collapseRow: (key: string) => string;
+    reorderRow: (key: string) => string;
+};
+export declare const defaultDataGridLabels: ResolvedDataGridLabels;

package/dist/components/composite/data-view/DataView.vue.d.ts

@@ -0,0 +1,54 @@
+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[];
+        idProperty?: string;
+        singleSelect?: boolean;
+        scrollbar?: Record<string, unknown>;
+        defaultSelected?: boolean | number[];
+        focusInner?: boolean;
+    } & {
+        onContextmenu?: ((item: T, index: number, event: MouseEvent) => any) | undefined;
+        onSelectionchange?: ((selectedIndexes: number | number[]) => any) | undefined;
+        "onSelected-change"?: ((selectedItems: (string | number)[]) => any) | undefined;
+        onRowclear?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        clearSelectedRows: () => void;
+        ensureItemVisible: (item: T) => boolean;
+        clickItem: (event: MouseEvent | KeyboardEvent, index: number, item: T) => void;
+        focusItem: (itemId: string | number) => boolean;
+        selectRange: (beginIndex: number, endIndex: number, options?: {
+            keepSelection?: boolean;
+        }) => boolean;
+        clearSelection: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        'outer-spin'?: (props: {}) => any;
+    } & {
+        before?: (props: {}) => any;
+    } & {
+        item?: (props: {
+            item: T;
+            index: number;
+            disabled: boolean;
+            selected: boolean;
+        }) => any;
+    } & {
+        after?: (props: {}) => any;
+    } & {
+        'inner-spin'?: (props: {}) => any;
+    };
+    emit: ((evt: "contextmenu", item: T, index: number, event: MouseEvent) => void) & ((evt: "selectionchange", selectedIndexes: number | number[]) => void) & ((evt: "selected-change", selectedItems: (string | number)[]) => void) & ((evt: "rowclear") => void);
+}>) => 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/footbar/Footbar.vue.d.ts

@@ -0,0 +1,13 @@
+import { FootbarButton } from './types';
+type __VLS_Props = {
+    buttons?: FootbarButton[];
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "click-button": (button: FootbarButton, event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onClick-button"?: ((button: FootbarButton, event: MouseEvent) => any) | undefined;
+}>, {
+    buttons: FootbarButton[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/composite/footbar/FootbarButtons.vue.d.ts

@@ -0,0 +1,13 @@
+import { FootbarButton } from './types';
+type __VLS_Props = {
+    buttons?: FootbarButton[];
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "click-button": (button: FootbarButton, event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onClick-button"?: ((button: FootbarButton, event: MouseEvent) => any) | undefined;
+}>, {
+    buttons: FootbarButton[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,32 @@
+import { Component } from 'vue';
+export type FootbarButtonRegion = 'left' | 'center' | 'right';
+export type FootbarButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger';
+export type FootbarButtonSize = 'sm' | 'md' | 'lg';
+/**
+ * Button description consumed by Footbar, AppActionBar and Panel's `fbar`.
+ *
+ * Rendering order is `region` first, then `order` (ascending), then the array
+ * position as a tie breaker — the array order alone never decides placement.
+ * A button without visible `text` is not rendered, so an icon-only action has
+ * to keep a readable label in `text`.
+ */
+export type FootbarButton = {
+    id: string;
+    text: string;
+    region?: FootbarButtonRegion;
+    order?: number;
+    variant?: FootbarButtonVariant;
+    size?: FootbarButtonSize;
+    disabled?: boolean;
+    icon?: Component;
+    onClick?: (event: MouseEvent) => void;
+};
+export type FootbarGroups = {
+    left: FootbarButton[];
+    center: FootbarButton[];
+    right: FootbarButton[];
+};
+/** Visible buttons in render order: region is not part of it, `order` and input index are. */
+export declare function sortFootbarButtons(buttons: FootbarButton[]): FootbarButton[];
+/** Visible buttons grouped by region, each group already in render order. */
+export declare function groupFootbarButtons(buttons: FootbarButton[]): FootbarGroups;

package/dist/components/composite/form/Form.vue.d.ts

@@ -0,0 +1,49 @@
+import { FormFieldHandle } from './context';
+import { FormDirection, FormRules, FormSpacing, FormValidatedResult, ValidateMessageDisplayMode, ValidateTrigger } from './types';
+type __VLS_Props = {
+    /** Rules keyed by `FormItem`'s `prop`; async-validator syntax. */
+    rules?: FormRules;
+    /** `'horizontal'` puts the label beside the control, `'vertical'` above it. */
+    direction?: FormDirection;
+    /** Gap between items; `'auto'` uses `dense` (horizontal) or `regular` (vertical). */
+    spacing?: FormSpacing;
+    /** Default message placement; a FormItem can override it. */
+    validateMessageDisplayMode?: ValidateMessageDisplayMode;
+};
+/** Validates every field; resolves `true` only when all of them pass. */
+declare function validate(trigger?: ValidateTrigger | null, options?: {
+    autoScroll?: boolean;
+}): Promise<boolean>;
+/** Validates one field by its `prop`; unknown props resolve `true`. */
+declare function validateField(prop: string): Promise<boolean>;
+/** Clears validation state and messages; field values stay untouched unless a FormItem declares `initialValue`. */
+declare function resetFields(): void;
+/** Makes the current values the new dirty baseline. */
+declare function commit(): void;
+declare function isDirty(): boolean;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    fields: import('vue').ShallowReactive<FormFieldHandle[]>;
+    validate: typeof validate;
+    validateField: typeof validateField;
+    resetFields: typeof resetFields;
+    commit: typeof commit;
+    isDirty: typeof isDirty;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: (event: Event) => any;
+    validated: (result: FormValidatedResult) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSubmit?: ((event: Event) => any) | undefined;
+    onValidated?: ((result: FormValidatedResult) => any) | undefined;
+}>, {}, {}, {}, {}, 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/form/FormItem.vue.d.ts

@@ -0,0 +1,132 @@
+import { FormFieldContext } from './context';
+import { FormItemValidateMessageDisplayMode, FormRule, ValidateStatus, ValidateTrigger } from './types';
+type __VLS_Props = {
+    /** Controlled field value; when `undefined` the value is reported by the control. */
+    modelValue?: unknown;
+    /** Key into the form's `rules`, and the identity used by `validateField()`. */
+    prop?: string;
+    /** Label text; `false` hides the label area entirely. */
+    label?: string | false;
+    /** Persistent description under the control. */
+    description?: string;
+    /** Message shown while the field is valid; a validation error replaces it. */
+    help?: string;
+    /** Rules for this field, running before the rules the form declares for `prop`. */
+    rules?: FormRule | FormRule[];
+    /** Marks the field required for screen readers; it does not add a `required` rule. */
+    requiredMark?: boolean;
+    /** Dims the label. */
+    disableLabel?: boolean;
+    /** Dims the description. */
+    disableDescription?: boolean;
+    /** Dims the control area without disabling anything. */
+    disableControl?: boolean;
+    /** Skips all validation for this field. */
+    disableValidation?: boolean;
+    /** Validates the field even while its control reports itself disabled. */
+    validateDisabledField?: boolean;
+    /** Runs validation but never renders its message. */
+    hideValidateMessage?: boolean;
+    /** Does not apply the `has-error` status class to the item. */
+    hideValidateStatusCls?: boolean;
+    /** Reports the control's disabled state; a control can also report it through `useFormField()`. */
+    disabled?: boolean;
+    /** Manual status; overrides the status produced by validation. */
+    validateStatus?: ValidateStatus;
+    /** `'form'` inherits the enclosing form's display mode. */
+    validateMessageDisplayMode?: FormItemValidateMessageDisplayMode;
+    /** Trigger assumed by rules that do not declare one. */
+    defaultValidateTrigger?: ValidateTrigger;
+    /** Validates once on mount. */
+    immediateValidate?: boolean;
+    /** The slot content is plain text, not a control. */
+    textOnly?: boolean;
+    /** Indentation level (multiples of 28px) or any CSS length. */
+    indent?: string | number;
+    /** Width of the label column in the horizontal layout. */
+    labelWidth?: string;
+    /** Value restored by `resetFields()`; also the initial dirty baseline. */
+    initialValue?: unknown;
+};
+declare function setFieldValue(next: unknown): void;
+declare function setInitValue(next: unknown): void;
+declare function commit(): void;
+declare function validate(trigger?: ValidateTrigger | null): Promise<boolean>;
+declare function showPopup(message?: string): void;
+declare function hidePopup(): void;
+/** Marks the field invalid from the outside; `ValidationPopup` and manual checks use this. */
+declare function setInvalid(message: string, state?: ValidateStatus): void;
+declare function resetInvalid(): void;
+declare function setDisabled(next: boolean): void;
+declare function resetField(): void;
+declare function ensureVisible(): void;
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {
+    field: FormFieldContext;
+}, __VLS_7: {
+    classes: {
+        afterItem: string;
+    };
+}, __VLS_9: {}, __VLS_11: {
+    field: FormFieldContext;
+};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_1) => any;
+} & {
+    before?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
+} & {
+    after?: (props: typeof __VLS_7) => any;
+} & {
+    description?: (props: typeof __VLS_9) => any;
+} & {
+    status?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    validate: typeof validate;
+    resetField: typeof resetField;
+    commit: typeof commit;
+    isDirty: import('vue').ComputedRef<boolean>;
+    setInvalid: typeof setInvalid;
+    resetInvalid: typeof resetInvalid;
+    showPopup: typeof showPopup;
+    hidePopup: typeof hidePopup;
+    setFieldValue: typeof setFieldValue;
+    setInitValue: typeof setInitValue;
+    setFieldDisabled: typeof setDisabled;
+    ensureVisible: typeof ensureVisible;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: unknown) => any;
+    validating: () => any;
+    validated: (result: {
+        message: string;
+        status: ValidateStatus;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
+    onValidating?: (() => any) | undefined;
+    onValidated?: ((result: {
+        message: string;
+        status: ValidateStatus;
+    }) => any) | undefined;
+}>, {
+    disabled: boolean;
+    requiredMark: boolean;
+    disableLabel: boolean;
+    disableDescription: boolean;
+    disableControl: boolean;
+    disableValidation: boolean;
+    validateDisabledField: boolean;
+    hideValidateMessage: boolean;
+    hideValidateStatusCls: boolean;
+    immediateValidate: boolean;
+    textOnly: 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/form/context.d.ts

@@ -0,0 +1,61 @@
+import { InjectionKey } from 'vue';
+import { FormRules, FormDirection, FormSpacing, ValidateMessageDisplayMode, ValidateStatus, ValidateTrigger } from './types';
+export declare const FORM_CONTEXT_KEY: InjectionKey<FormContext>;
+export declare const FORM_FIELD_KEY: InjectionKey<FormFieldContext>;
+/** What Form exposes to its FormItems. Values are unwrapped (the provided object is reactive). */
+export type FormContext = {
+    rules: FormRules;
+    direction: FormDirection;
+    spacing: FormSpacing;
+    validateMessageDisplayMode: ValidateMessageDisplayMode;
+    registerField: (field: FormFieldHandle) => void;
+    unregisterField: (field: FormFieldHandle) => void;
+};
+/** One registered FormItem, as used by `Form.validate()` / `resetFields()` / `commit()`. */
+export type FormFieldHandle = {
+    prop: string;
+    /** Runs this field's rules; resolves with the first error message, or `null` when valid. */
+    validate: (trigger?: ValidateTrigger | null) => Promise<string | null>;
+    resetField: () => void;
+    commit: () => void;
+    isDirty: () => boolean;
+    /** Scrolls the field into view; used by `Form.validate()` for the first invalid field. */
+    ensureVisible: () => void;
+};
+/**
+ * Field state published by FormItem to its default slot (as the `field` slot
+ * prop) and to `useFormField()` consumers. It is reactive, so a control can
+ * read `field.invalid`, `field.status` and `field.message` directly.
+ */
+export type FormFieldContext = {
+    controlId: string;
+    descriptionId: string | undefined;
+    messageId: string | undefined;
+    /** Value for `aria-describedby`, covering the rendered description and message. */
+    describedBy: string | undefined;
+    /** True when the item is marked required (`requiredMark`), for `aria-required`. */
+    required: boolean;
+    disabled: boolean;
+    invalid: boolean;
+    status: ValidateStatus;
+    /** Current help or validation message; empty when the field has nothing to say. */
+    message: string;
+    validate: (trigger?: ValidateTrigger | null) => Promise<boolean>;
+    /** Opens the floating message (popup display mode) with an optional message. */
+    showPopup: (message?: string) => void;
+    hidePopup: () => void;
+    /** Reports the control's value; used for uncontrolled usage and dirty checks. */
+    setValue: (value: unknown) => void;
+    /** Reports the control's own disabled state so the label and description dim. */
+    setDisabled: (disabled: boolean) => void;
+    /** Runs the `blur` trigger of this field's rules. */
+    onBlur: () => void;
+    /** Runs the `change` trigger of this field's rules. */
+    onChange: () => void;
+    /** `id`, `aria-*` and trigger listeners to spread on the control. */
+    controlProps: Record<string, unknown>;
+};
+/** The enclosing form, or `null` when the item is used standalone. */
+export declare function useFormContext(): FormContext | null;
+/** The enclosing form item of a control, or `null` outside a FormItem. */
+export declare function useFormField(): FormFieldContext | null;

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

@@ -0,0 +1,17 @@
+import { FormRule, FormRuleType, ValidateTrigger } from './types';
+export type ValidateRulesOptions = {
+    /** `null` runs every rule regardless of its `trigger`; `undefined` also runs every rule. */
+    trigger?: ValidateTrigger | null;
+    /** Trigger assumed by rules that do not declare one. Defaults to `'blur'`. */
+    defaultTrigger?: ValidateTrigger;
+};
+/** A rule, or a shorthand list of rules, as one array. */
+export declare function normalizeRules(rules: FormRule | FormRule[] | null | undefined): FormRule[];
+/**
+ * `null`/`undefined` are empty, so is a whitespace-only string (async-validator's
+ * `whitespace: true` default) and an empty array. `false` and `0` are values, so
+ * a boolean field that must be turned on needs a `validator`, not `required`.
+ */
+export declare function isEmptyValue(value: unknown, type?: FormRuleType): boolean;
+/** Runs `rules` against `value` and resolves with the first error message, or `null`. */
+export declare function validateWithRules(value: unknown, rules: FormRule | FormRule[] | null | undefined, options?: ValidateRulesOptions): Promise<string | null>;