nuxt-ui-tools 1.17.1 → 1.19.0

package/dist/runtime/form/utils/options.d.ts

@@ -1,24 +1,69 @@
-import type { FormValue, FormFieldCallbackParams, FormOptionItem, FormOptionValue } from '../types/index.js';
+import type { FormValue, FormField, FormFieldCallbackParams, FormOptionItem, FormOptionValue, ResolvedFormOption } from '../types/index.js';
 export interface FormOptionKeys {
     value?: string;
     label?: string;
     children?: string;
+    /**
+     * Property holding the heading an option is listed under. Options are not grouped without it:
+     * a `group` property is never read unless it is mapped here.
+     */
+    group?: string;
 }
-export interface ResolvedFormOption {
-    value: FormOptionValue;
-    label: string;
-    description?: string;
-    disabled?: boolean;
-    icon?: string;
-    children?: readonly ResolvedFormOption[];
-    /** True when the option has children that load on demand. */
-    lazy?: boolean;
-}
+export type { ResolvedFormOption } from '../types/index.js';
+/** The one visual an option draws before its label: its icon, else its avatar, else its chip. */
+export type OptionLeading = 'icon' | 'avatar' | 'chip';
+export declare function resolveOptionLeading(option: ResolvedFormOption): OptionLeading | undefined;
+export declare function resolveOptionDescriptionIndent(option: ResolvedFormOption): string | undefined;
 export declare function normalizeOptionItem(option: FormValue, keys?: FormOptionKeys): ResolvedFormOption;
 export declare function normalizeOptionItems(options: readonly FormValue[] | undefined, keys?: FormOptionKeys): ResolvedFormOption[];
+/**
+ * The `options` of a field as authored: its array, function or query source, whether given
+ * directly or inside a `source` property.
+ */
+export declare function readOptionSource(field: FormField): FormValue;
+/**
+ * Property the options of a field hold their heading in, for the field kinds that list options
+ * under headings. The field's `groupKey` names it, read statically from the definition like
+ * `labelKey` and `valueKey`. Without it, options written inline in the schema group by their
+ * `group`, the way a literal option is authored. The records a function, a promise or a query
+ * returns belong to the author's data, so a `group` they happen to carry is not read until
+ * `groupKey` maps it. `groupKey: false` opts out.
+ */
+export declare function resolveOptionGroupKey(field: FormField): string | undefined;
+export interface OptionGroup<TItem> {
+    /** Stable key of the group: its heading, or an empty string for the options without one. */
+    key: string;
+    /** Heading shown above the options of the group; none for options that declare no group. */
+    heading?: string;
+    /** The group's options, as the mutable list the Nuxt UI groups take. */
+    items: TItem[];
+}
+/**
+ * Lists options under their group headings. Headings follow the order in which they first appear
+ * in `items`, and each keeps its options in their authored order. The options without a group form
+ * one more group with no heading, placed where its first option appears. Without any group the
+ * result is a single headingless group, so an ungrouped list renders as it always did.
+ */
+export declare function groupOptions<TItem extends {
+    group?: string;
+}>(items: readonly TItem[]): readonly OptionGroup<TItem>[];
 export declare const LOAD_MORE_OPTION_VALUE = "__nut:load-more__";
 export declare function isLoadMoreOption(item: FormValue): boolean;
 export declare function appendLoadMoreOption(items: readonly ResolvedFormOption[], show: boolean, label: string): readonly ResolvedFormOption[];
+/** Item of a Nuxt UI menu: an option, or the heading (`type: 'label'`) the menu draws above a group. */
+export type OptionMenuItem = ResolvedFormOption & {
+    type?: 'label';
+};
+/**
+ * Items for the Nuxt UI menu of a select or auto-complete: the options as one flat list, or, when
+ * some options belong to a group, one array per group with a heading item first. Nuxt UI draws
+ * each array as a group and keeps a heading only while its group still has a match for the search.
+ * The load-more row, when shown, is last and belongs to no group.
+ */
+export declare function toMenuItems(options: readonly ResolvedFormOption[], loadMore: {
+    show: boolean;
+    label: string;
+}): OptionMenuItem[] | OptionMenuItem[][];
 export declare function formOptionKey(value: FormOptionValue): string;
 export declare function flattenResolvedOptions(options: readonly ResolvedFormOption[]): readonly ResolvedFormOption[];
 export declare function mergeResolvedOptions(...collections: readonly (readonly ResolvedFormOption[])[]): readonly ResolvedFormOption[];

package/dist/runtime/form/utils/options.js

@@ -1,21 +1,55 @@
+import { createFormFieldInstance } from "./field-instance.js";
 import { isRecord } from "./path.js";
 import { isBoolean, isFunction, isNumber, isString, isUndefined } from "./predicate.js";
 import { resolveFormText } from "./text.js";
+const DEFAULT_GROUP_KEY = "group";
+const CHIP_COLORS = [
+  "primary",
+  "secondary",
+  "success",
+  "info",
+  "warning",
+  "error",
+  "neutral"
+];
+export function resolveOptionLeading(option) {
+  if (option.icon) return "icon";
+  if (option.avatar) return "avatar";
+  if (option.chip) return "chip";
+  return void 0;
+}
+const DESCRIPTION_INDENT = {
+  avatar: "ps-8",
+  chip: "ps-6",
+  icon: "ps-6"
+};
+export function resolveOptionDescriptionIndent(option) {
+  const leading = resolveOptionLeading(option);
+  return leading ? DESCRIPTION_INDENT[leading] : void 0;
+}
 export function normalizeOptionItem(option, keys = {}) {
+  const item = isFormOptionItem(option) ? option : void 0;
   if (isRecord(option)) {
     const rawValue = readOptionProperty(option, keys.value ?? "value");
     const fallbackValue = isUndefined(rawValue) ? option.key : rawValue;
     const rawChildren = readOptionProperty(option, keys.children ?? "children");
     const rawDescription = readOptionProperty(option, "description");
+    const rawGroup = keys.group ? readOptionProperty(option, keys.group) : void 0;
     const children = Array.isArray(rawChildren) ? rawChildren.map((child) => normalizeOptionItem(child, keys)) : void 0;
     const lazy = option.isLeaf === false || option.hasChildren === true;
     const value = normalizeOptionValue(fallbackValue);
     const rawIcon = readOptionProperty(option, "icon");
+    const rawSuffix = readOptionProperty(option, "suffix");
     const normalized = {
+      avatar: normalizeOptionAvatar(readOptionProperty(option, "avatar")),
+      chip: normalizeOptionChip(readOptionProperty(option, "chip")),
       description: isFormText(rawDescription) ? resolveFormText(rawDescription) : void 0,
       disabled: option.disabled === true,
+      group: isFormText(rawGroup) ? resolveFormText(rawGroup) : void 0,
       icon: isString(rawIcon) ? rawIcon : void 0,
+      item,
       label: resolveFormText(readOptionProperty(option, keys.label ?? "label")) ?? String(value),
+      suffix: isFormText(rawSuffix) ? resolveFormText(rawSuffix) : void 0,
       value
     };
     if (children) {
@@ -29,13 +63,52 @@ export function normalizeOptionItem(option, keys = {}) {
     return normalized;
   }
   return {
+    item,
     label: String(option),
     value: normalizeOptionValue(option)
   };
 }
+function isFormOptionItem(value) {
+  return isOptionValue(value) || isRecord(value);
+}
+function normalizeOptionAvatar(raw) {
+  if (!isRecord(raw)) return void 0;
+  const { alt, src, text } = raw;
+  return {
+    alt: isString(alt) ? alt : void 0,
+    src: isString(src) ? src : void 0,
+    text: isString(text) ? text : void 0
+  };
+}
+function normalizeOptionChip(raw) {
+  if (!isRecord(raw)) return void 0;
+  return { color: CHIP_COLORS.find((color) => color === raw.color) };
+}
 export function normalizeOptionItems(options, keys = {}) {
   return (options ?? []).map((option) => normalizeOptionItem(option, keys));
 }
+export function readOptionSource(field) {
+  const options = Object.getOwnPropertyDescriptor(field, "options")?.value;
+  return isRecord(options) && "source" in options ? options.source : options;
+}
+export function resolveOptionGroupKey(field) {
+  if (!createFormFieldInstance(field).capability.has("optionGroups")) return void 0;
+  const mapped = Object.getOwnPropertyDescriptor(field, "groupKey")?.value;
+  if (mapped === false) return void 0;
+  if (isString(mapped) && mapped) return mapped;
+  return Array.isArray(readOptionSource(field)) ? DEFAULT_GROUP_KEY : void 0;
+}
+export function groupOptions(items) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = item.group?.trim() ?? "";
+    const members = groups.get(key);
+    if (members) members.push(item);
+    else groups.set(key, [item]);
+  }
+  if (groups.size === 0) return [{ items: [], key: "" }];
+  return [...groups].map(([key, members]) => ({ heading: key || void 0, items: members, key }));
+}
 export const LOAD_MORE_OPTION_VALUE = "__nut:load-more__";
 export function isLoadMoreOption(item) {
   return isRecord(item) && item.value === LOAD_MORE_OPTION_VALUE;
@@ -46,6 +119,19 @@ export function appendLoadMoreOption(items, show, label) {
   }
   return [...items, { disabled: true, label, value: LOAD_MORE_OPTION_VALUE }];
 }
+function menuHeading(heading) {
+  return { label: heading, type: "label", value: "" };
+}
+export function toMenuItems(options, loadMore) {
+  const groups = groupOptions(options);
+  if (!groups.some((group) => group.heading)) {
+    return [...appendLoadMoreOption(options, loadMore.show, loadMore.label)];
+  }
+  const nested = groups.map(
+    (group) => group.heading ? [menuHeading(group.heading), ...group.items] : group.items
+  );
+  return loadMore.show ? [...nested, [...appendLoadMoreOption([], true, loadMore.label)]] : nested;
+}
 export function formOptionKey(value) {
   const type = isString(value) ? "string" : isNumber(value) ? "number" : isBoolean(value) ? "boolean" : "unknown";
   return `${type}:${String(value)}`;

package/dist/runtime/form/utils/page-surface.d.ts

@@ -0,0 +1,26 @@
+import type { FormPageSurface, FormValue } from '../types/index.js';
+/**
+ * What a surface sets on the parts of a form page it restyles. These are the default classes of
+ * each slot: the `FormPageUi` slots merge over them.
+ */
+export interface FormPageSurfaceClasses {
+    /** Background the sections sit on. */
+    root: string;
+    /** Gap between the sections. */
+    sections: string;
+    /** The box of a card, or the spacing, hairline, and modified marker of a plain section. */
+    section: string;
+    /** Where the description sits against the title. */
+    sectionDescription: string;
+    /** Placeholder shown while the schema context loads. */
+    sectionSkeleton: string;
+}
+/**
+ * The centered column of a page without a navigation. The body and the row of the header share
+ * it, so both start and end on the same edges, padding included.
+ */
+export declare const FORM_PAGE_COLUMN = "mx-auto w-full max-w-[816px]";
+export declare const DEFAULT_FORM_PAGE_SURFACE: FormPageSurface;
+/** The surface a page draws its sections with, `card` unless the config names a known one. */
+export declare function resolveFormPageSurface(value: FormValue): FormPageSurface;
+export declare function getFormPageSurfaceClasses(surface: FormPageSurface): FormPageSurfaceClasses;

package/dist/runtime/form/utils/page-surface.js

@@ -0,0 +1,28 @@
+import { isString } from "./predicate.js";
+export const FORM_PAGE_COLUMN = "mx-auto w-full max-w-[816px]";
+export const DEFAULT_FORM_PAGE_SURFACE = "card";
+const FORM_PAGE_SURFACES = {
+  card: {
+    root: "bg-muted",
+    section: "gap-[18px] rounded-xl border border-default bg-default px-5 pt-5 pb-6 transition-[border-color,box-shadow] duration-200 @3xl/form-page:px-6 @3xl/form-page:pt-[22px] data-[dirty]:border-primary data-[dirty]:ring-4 data-[dirty]:ring-primary/20 data-[dirty]:ring-inset",
+    sectionDescription: "order-last basis-full @3xl/form-page:order-none @3xl/form-page:basis-auto",
+    sectionSkeleton: "rounded-xl border border-default bg-default px-6 pt-[22px] pb-6",
+    sections: "gap-[18px]"
+  },
+  plain: {
+    root: "bg-default",
+    section: "relative gap-[18px] border-t border-default py-8 first:border-t-0 first:pt-0 last:pb-0 before:pointer-events-none before:absolute before:inset-y-8 before:-start-3 before:w-0.5 before:rounded-full before:transition-colors first:before:top-0 last:before:bottom-0 data-[dirty]:before:bg-primary",
+    sectionDescription: "order-last basis-full",
+    sectionSkeleton: "border-t border-default py-8 first:border-t-0 first:pt-0",
+    sections: "gap-0"
+  }
+};
+export function resolveFormPageSurface(value) {
+  return isFormPageSurface(value) ? value : DEFAULT_FORM_PAGE_SURFACE;
+}
+export function getFormPageSurfaceClasses(surface) {
+  return FORM_PAGE_SURFACES[surface];
+}
+function isFormPageSurface(value) {
+  return isString(value) && Object.hasOwn(FORM_PAGE_SURFACES, value);
+}

package/dist/runtime/form/utils/page.d.ts

@@ -1,10 +1,30 @@
-import type { FormObject, FormPageSectionEntry, FormPageSectionState, FormRuntime, FormValue } from '../types/index.js';
+import type { FormObject, FormPageSectionEntry, FormPageSectionState, FormPageSectionStatus, FormRuntime, FormValue } from '../types/index.js';
 /** Pairs each section of a page schema with the card `defineFormPageSchema` generated for it. */
 export declare function getFormPageSections(schema: FormValue): readonly FormPageSectionEntry[];
 /** Resolved heading of the page navigation. */
 export declare function getFormPageNavigationTitle(schema: FormValue): string | undefined;
+/**
+ * Number of visible sections the navigation needs to show. Zero, the default, shows it whatever
+ * the number of sections; anything that is not a count above one means the same.
+ */
+export declare function getFormPageNavigationMinSections(schema: FormValue): number;
 /** True while the section's `condition` lets it render. */
 export declare function isFormPageSectionVisible(entry: FormPageSectionEntry, runtime: FormRuntime): boolean;
+/**
+ * Where a section stands, from what it shows and what it still misses. An optional section nothing
+ * was entered in is `optional`, not `pending`: the user has nothing to do there.
+ */
+export declare function resolveFormPageSectionStatus(params: {
+    /** The section shows a validation error, which needs the user to leave a field or submit. */
+    invalid: boolean;
+    /** Number of required fields without a value. */
+    missing: number;
+    optional: boolean;
+    /** The user entered a value, or the form input brought one. Only read for an optional section. */
+    provided: boolean;
+}): FormPageSectionStatus;
+/** True while the section keeps the form from being submitted: the sections left to complete. */
+export declare function isFormPageSectionBlocking(section: Pick<FormPageSectionState, 'status'>): boolean;
 /**
  * Live state of one visible section: what it still misses, whether it shows errors, and what
  * changed since the baseline.

package/dist/runtime/form/utils/page.js

@@ -13,6 +13,12 @@ import {
   resolveRequired
 } from "./state.js";
 import { resolveFormText } from "./text.js";
+const BLOCKS_SUBMIT = {
+  complete: false,
+  invalid: true,
+  optional: false,
+  pending: true
+};
 export function getFormPageSections(schema) {
   if (!isRecord(schema) || !Array.isArray(schema.sections)) {
     return [];
@@ -30,9 +36,25 @@ export function getFormPageNavigationTitle(schema) {
   const { title } = schema.navigation;
   return isFormText(title) ? resolveFormText(title) : void 0;
 }
+export function getFormPageNavigationMinSections(schema) {
+  if (!isRecord(schema) || !isRecord(schema.navigation)) {
+    return 0;
+  }
+  const { minSections } = schema.navigation;
+  return isNumber(minSections) && minSections > 1 ? Math.trunc(minSections) : 0;
+}
 export function isFormPageSectionVisible(entry, runtime) {
   return !hasCondition(entry.card) || runtime.shouldRender(entry.card, [entry.card.key]);
 }
+export function resolveFormPageSectionStatus(params) {
+  if (params.invalid) return "invalid";
+  if (params.missing > 0) return "pending";
+  if (params.optional && !params.provided) return "optional";
+  return "complete";
+}
+export function isFormPageSectionBlocking(section) {
+  return BLOCKS_SUBMIT[section.status];
+}
 export function resolveFormPageSectionState(params) {
   const { entry, runtime } = params;
   const leaves = collectVisibleLeaves(entry.section.fields, [], runtime);
@@ -43,7 +65,7 @@ export function resolveFormPageSectionState(params) {
   const required = params.requiredEnforced ? leaves.filter((leaf) => isRequiredLeaf(leaf, runtime)) : [];
   const missing = required.filter((leaf) => isEmptyValue(runtime.getValue(leaf.path))).length;
   const optional = entry.section.optional ?? required.every((leaf) => leaf.item);
-  const filled = !optional || leaves.some((leaf) => isProvided(leaf, runtime, dirtyPaths, params.input));
+  const provided = optional && leaves.some((leaf) => isProvided(leaf, runtime, dirtyPaths, params.input));
   return {
     description: resolveFormText(entry.section.description),
     dirty: dirtyPaths.length > 0,
@@ -53,7 +75,7 @@ export function resolveFormPageSectionState(params) {
     label: resolveFormText(entry.section.label) ?? entry.section.key,
     missing,
     optional,
-    status: invalid ? "invalid" : missing === 0 && filled ? "complete" : "pending"
+    status: resolveFormPageSectionStatus({ invalid, missing, optional, provided })
   };
 }
 function collectVisibleLeaves(fields, parentPath, runtime, item = false) {

package/dist/runtime/i18n/locales/en.js

@@ -198,6 +198,7 @@ export default defineUiToolsLocale({
       },
       actions: {
         cancelButton: "Cancel",
+        closeButton: "Close form",
         nextButton: "Next",
         prevButton: "Back",
         resetButton: "Reset",
@@ -208,14 +209,14 @@ export default defineUiToolsLocale({
         modifiedOne: "{count} modified.",
         modifiedOther: "{count} modified.",
         navigation: "Form sections",
-        optional: "optional",
         remaining: "{count} left to complete.",
         resetSection: "Reset",
         sectionsOne: "{count} section",
         sectionsOther: "{count} sections",
         status: {
-          complete: "Complete",
-          invalid: "Has errors",
+          complete: "Completed",
+          invalid: "To fix",
+          optional: "Optional",
           pending: "To complete"
         },
         unmodified: "No unsaved changes.",
@@ -284,9 +285,13 @@ export default defineUiToolsLocale({
         rating: {
           value: "{value} of {max}"
         },
+        shell: {
+          collapse: "Collapse",
+          expand: "Expand",
+          reset: "Reset field"
+        },
         text: {
-          clear: "Clear",
-          defaultPlaceholder: "Enter a value"
+          clear: "Clear"
         },
         time: {
           clear: "Clear time",
@@ -294,6 +299,10 @@ export default defineUiToolsLocale({
           hour: "Hour",
           minute: "Minute"
         },
+        unsupported: {
+          description: 'The "{type}" field type cannot be displayed.',
+          title: "Unsupported field"
+        },
         upload: {
           cancel: "Cancel upload",
           failed: "Upload failed.",
@@ -314,6 +323,9 @@ export default defineUiToolsLocale({
           title: "Form data unavailable"
         }
       },
+      steps: {
+        fallback: "Step {number}"
+      },
       validation: {
         dateMax: "The date must be on or before {max}",
         dateMin: "The date must be on or after {min}",
@@ -692,8 +704,18 @@ export default defineUiToolsLocale({
       header: {
         gridView: "Grid view",
         refreshData: "Refresh data",
+        summaryView: "List view",
         tableView: "Table view"
       },
+      rowActions: {
+        label: "Actions for {label}",
+        labelAt: "Actions for row {position}"
+      },
+      selection: {
+        selectAll: "Select all rows",
+        selectRow: "Select {label}",
+        selectRowAt: "Select row {position}"
+      },
       selectionBar: {
         allResults: "All results",
         clear: "Clear selection",
@@ -732,9 +754,7 @@ export default defineUiToolsLocale({
         collapse: "Collapse row",
         collapseAll: "Collapse all rows",
         expand: "Expand row",
-        expandAll: "Expand all rows",
-        selectAll: "Select all rows",
-        selectRow: "Select row"
+        expandAll: "Expand all rows"
       }
     }
   },

package/dist/runtime/i18n/locales/fr.js

@@ -198,6 +198,7 @@ export default defineUiToolsLocale({
       },
       actions: {
         cancelButton: "Annuler",
+        closeButton: "Fermer le formulaire",
         nextButton: "Suivant",
         prevButton: "Pr\xE9c\xE9dent",
         resetButton: "R\xE9initialiser",
@@ -208,14 +209,14 @@ export default defineUiToolsLocale({
         modifiedOne: "{count} modifi\xE9e.",
         modifiedOther: "{count} modifi\xE9es.",
         navigation: "Sections du formulaire",
-        optional: "optionnel",
         remaining: "{count} \xE0 compl\xE9ter.",
         resetSection: "R\xE9initialiser",
         sectionsOne: "{count} section",
         sectionsOther: "{count} sections",
         status: {
-          complete: "Compl\xE8te",
-          invalid: "Contient des erreurs",
+          complete: "Compl\xE9t\xE9",
+          invalid: "\xC0 corriger",
+          optional: "Facultatif",
           pending: "\xC0 compl\xE9ter"
         },
         unmodified: "Aucune modification en cours.",
@@ -284,9 +285,13 @@ export default defineUiToolsLocale({
         rating: {
           value: "{value} sur {max}"
         },
+        shell: {
+          collapse: "Replier",
+          expand: "D\xE9plier",
+          reset: "R\xE9initialiser le champ"
+        },
         text: {
-          clear: "Effacer",
-          defaultPlaceholder: "Saisissez une valeur"
+          clear: "Effacer"
         },
         time: {
           clear: "Effacer l\u2019heure",
@@ -294,6 +299,10 @@ export default defineUiToolsLocale({
           hour: "Heure",
           minute: "Minute"
         },
+        unsupported: {
+          description: "Le type de champ \xAB {type} \xBB ne peut pas \xEAtre affich\xE9.",
+          title: "Champ non pris en charge"
+        },
         upload: {
           cancel: "Annuler le t\xE9l\xE9versement",
           failed: "\xC9chec du t\xE9l\xE9versement.",
@@ -314,6 +323,9 @@ export default defineUiToolsLocale({
           title: "Donn\xE9es du formulaire indisponibles"
         }
       },
+      steps: {
+        fallback: "\xC9tape {number}"
+      },
       validation: {
         dateMax: "La date doit \xEAtre au plus tard le {max}",
         dateMin: "La date doit \xEAtre au plus t\xF4t le {min}",
@@ -692,8 +704,18 @@ export default defineUiToolsLocale({
       header: {
         gridView: "Vue grille",
         refreshData: "Actualiser les donn\xE9es",
+        summaryView: "Vue liste",
         tableView: "Vue tableau"
       },
+      rowActions: {
+        label: "Actions pour {label}",
+        labelAt: "Actions pour la ligne {position}"
+      },
+      selection: {
+        selectAll: "S\xE9lectionner toutes les lignes",
+        selectRow: "S\xE9lectionner {label}",
+        selectRowAt: "S\xE9lectionner la ligne {position}"
+      },
       selectionBar: {
         allResults: "Tous les r\xE9sultats",
         clear: "Effacer la s\xE9lection",
@@ -732,9 +754,7 @@ export default defineUiToolsLocale({
         collapse: "Replier la ligne",
         collapseAll: "Replier toutes les lignes",
         expand: "D\xE9plier la ligne",
-        expandAll: "D\xE9plier toutes les lignes",
-        selectAll: "S\xE9lectionner toutes les lignes",
-        selectRow: "S\xE9lectionner la ligne"
+        expandAll: "D\xE9plier toutes les lignes"
       }
     }
   },

package/dist/runtime/i18n/types.d.ts

@@ -2,8 +2,11 @@ import type { DeepPartial } from '#ui-tools/shared/types/utils';
 export interface UiToolsTableMessages {
     header: {
         refreshData: string;
+        /** Names the table layout, and the toggle that leaves summary rows for the table. */
         tableView: string;
         gridView: string;
+        /** Toggle that brings summary rows back from the table. */
+        summaryView: string;
     };
     footer: {
         rowsSelected: string;
@@ -12,6 +15,7 @@ export interface UiToolsTableMessages {
         range: string;
         rangeEmpty: string;
         pageOf: string;
+        /** Accessible name of a page button: "Page {current} of {total}". */
         page: string;
         pageSizeOption: string;
         previousPage: string;
@@ -19,6 +23,21 @@ export interface UiToolsTableMessages {
         firstPage: string;
         lastPage: string;
     };
+    /** Accessible names of the selection checkboxes. */
+    selection: {
+        selectAll: string;
+        /** A record with a label: "Select {label}". */
+        selectRow: string;
+        /** A record without one, by its position on the page: "Select row {position}". */
+        selectRowAt: string;
+    };
+    /** Accessible names of a row's actions menu. */
+    rowActions: {
+        /** A record with a label: "Actions for {label}". */
+        label: string;
+        /** A record without one, by its position on the page: "Actions for row {position}". */
+        labelAt: string;
+    };
     controls: {
         addFilter: string;
         clearSearch: string;
@@ -55,8 +74,6 @@ export interface UiToolsTableMessages {
         collapse: string;
         expandAll: string;
         collapseAll: string;
-        selectRow: string;
-        selectAll: string;
     };
     columnsMenu: {
         sortAsc: string;
@@ -429,13 +446,13 @@ export interface UiToolsFormMessages {
         submitButton: string;
         cancelButton: string;
         resetButton: string;
+        /** Accessible name of the close button of a modal, drawer, or fullscreen form. */
+        closeButton: string;
     };
     /** Form page chrome. Counts use `Intl.PluralRules`: `One` for "one", `Other` otherwise. */
     page: {
         /** Accessible name of the section navigation when the schema gives it no title. */
         navigation: string;
-        /** Marks an optional section, in the navigation and on its card. */
-        optional: string;
         /** Badge under the page title and name of a section's dirty marker. */
         unsavedChanges: string;
         /** Button of a modified section that puts its values back. */
@@ -452,11 +469,19 @@ export interface UiToolsFormMessages {
         modifiedOther: string;
         /** Navigation summary of a form with dirty checking and no change. */
         unmodified: string;
-        /** Accessible status of a navigation entry. */
+        /**
+         * Where a section stands: the accessible status of a navigation entry, and the tag that marks
+         * an optional section nothing was entered in (`optional`), in the navigation and on its card.
+         */
         status: {
+            /** Nothing required is missing and no field shows an error. */
             complete: string;
-            pending: string;
+            /** A field shows an error, once the user left it or tried to submit. */
             invalid: string;
+            /** An optional section nobody entered a value in. */
+            optional: string;
+            /** A required field has no value yet. */
+            pending: string;
         };
     };
     states: {
@@ -466,6 +491,10 @@ export interface UiToolsFormMessages {
             action: string;
         };
     };
+    steps: {
+        /** Name of a step that declares no title: "Step {number}". */
+        fallback: string;
+    };
     validation: {
         required: string;
         dateMin: string;
@@ -473,7 +502,6 @@ export interface UiToolsFormMessages {
     };
     fields: {
         text: {
-            defaultPlaceholder: string;
             clear: string;
         };
         description: {
@@ -562,6 +590,17 @@ export interface UiToolsFormMessages {
             number: string;
             clear: string;
         };
+        /** Chrome around a stateful field: its collapsible body and its dirty-reset button. */
+        shell: {
+            collapse: string;
+            expand: string;
+            reset: string;
+        };
+        /** Fallback for a field kind that has no renderer: "{type}" is the kind. */
+        unsupported: {
+            title: string;
+            description: string;
+        };
     };
 }
 export interface UiToolsDashboardMessages {

package/dist/runtime/spreadsheet/components/internal/spreadsheet-import-column-row.d.vue.ts

@@ -6,12 +6,12 @@ type __VLS_Props = {
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     reset: () => any;
-    assign: (header: number) => any;
     ignore: () => any;
+    assign: (header: number) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onReset?: (() => any) | undefined;
-    onAssign?: ((header: number) => any) | undefined;
     onIgnore?: (() => any) | undefined;
+    onAssign?: ((header: number) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;