@jirawatpyk/aura-react 5.2.0 → 5.4.0

package/dist/esm/Combobox.js

@@ -1,6 +1,6 @@
 'use client';
 import * as React from "react";
-import { useStrings } from "./locale.js";
+import { useStrings, useDensity } from "./locale.js";
 import { createPortal } from "react-dom";
 import { cx, uid, useMaybeControlled, useMounted, useIsoLayoutEffect, useMergedRef } from "./internal.js";
 import { Icon } from "./Icon.js";
@@ -24,6 +24,7 @@ const Combobox = React.forwardRef(
     const multi = all.multiple === true;
     const mp = all;
     const t = useStrings();
+    const density = useDensity();
     const auto = uid(), id = props.id || auto, listId = id + "-list";
     const options = (props.options || []).map(toOpt);
     const st = useMaybeControlled(
@@ -187,7 +188,7 @@ const Combobox = React.forwardRef(
       return id + "-opt-" + i;
     };
     const list = open && mounted && posState[0] ? createPortal(
-      /* @__PURE__ */ React.createElement("div", { ref: listRef, className: "aura-combo__popover", style: posState[0] }, live.length ? /* @__PURE__ */ React.createElement(
+      /* @__PURE__ */ React.createElement("div", { ref: listRef, "data-density": density, className: "aura-combo__popover", style: posState[0] }, live.length ? /* @__PURE__ */ React.createElement(
         "ul",
         {
           id: listId,

package/dist/esm/Select.js

@@ -1,9 +1,55 @@
 'use client';
 import * as React from "react";
+import { createPortal } from "react-dom";
 import { FIELD_KEYS, Field, describedBy } from "./Field.js";
 import { Icon } from "./Icon.js";
-import { cx, omit, uid } from "./internal.js";
+import { useDensity } from "./locale.js";
+import { cx, devWarnOnce, omit, uid, useIsoLayoutEffect, useMergedRef, useMounted } from "./internal.js";
 const h = React.createElement;
+const FORM_KEYS = ["name", "form", "value", "defaultValue", "disabled", "autoComplete", "onInput", "onInvalid"];
+const HANDLED_KEYS = FORM_KEYS.concat([
+  "onChange",
+  "onBlur",
+  "onFocus",
+  "onKeyDown",
+  "onClick",
+  "autoFocus",
+  "tabIndex",
+  "aria-label",
+  "aria-labelledby",
+  "aria-describedby",
+  "multiple",
+  "size"
+]);
+function pick(o, keys) {
+  const r = {};
+  for (const k of keys) if (k in o) r[k] = o[k];
+  return r;
+}
+function readItems(el) {
+  if (!el) return [];
+  return Array.prototype.map.call(el.options, function(o, i) {
+    const g = o.parentElement && o.parentElement.tagName === "OPTGROUP" ? o.parentElement : null;
+    return {
+      value: o.value,
+      label: o.textContent || "",
+      disabled: o.disabled || !!(g && g.disabled),
+      group: g ? g.label : null,
+      index: i
+    };
+  });
+}
+function initialLabel(props) {
+  const opts = (props.options || []).map(function(o) {
+    return typeof o === "object" ? o : { value: o, label: o };
+  });
+  const v = props.value !== void 0 && props.value !== null ? String(props.value) : props.defaultValue !== void 0 && props.defaultValue !== null ? String(props.defaultValue) : props.placeholder ? "" : opts[0] ? opts[0].value : "";
+  const hit = opts.filter(function(o) {
+    return o.value === v;
+  })[0];
+  if (hit) return { label: hit.label, empty: false };
+  return { label: props.placeholder || "", empty: true };
+}
 const Select = React.forwardRef(function Select2(props, ref) {
   const auto = uid(), id = props.id || auto;
   const rest = omit(props, FIELD_KEYS.concat(["children"]));
@@ -16,10 +62,267 @@ const Select = React.forwardRef(function Select2(props, ref) {
       /* @__PURE__ */ React.createElement("option", { key: "__ph", value: "", disabled: true }, props.placeholder)
     );
   const extra = props.value === void 0 && props.defaultValue === void 0 && props.placeholder ? { defaultValue: "" } : {};
-  return /* @__PURE__ */ React.createElement(
+  const native = !!props.multiple || props.size != null && props.size > 1;
+  const mounted = useMounted();
+  const live = !native && mounted;
+  const density = useDensity();
+  React.useEffect(function() {
+    if (props.label || props["aria-label"] || props["aria-labelledby"] || props.title) return;
+    if (document.querySelector('label[for="' + id.replace(/["\\]/g, "\\$&") + '"]')) return;
+    devWarnOnce(
+      "select-name",
+      "Select needs a label, aria-label or aria-labelledby: screen readers announce it with no name."
+    );
+  }, []);
+  const selRef = React.useRef(null), trigRef = React.useRef(null), listRef = React.useRef(null);
+  const shown = React.useState(function() {
+    return initialLabel(props);
+  });
+  const openState = React.useState(false), open = openState[0];
+  const activeState = React.useState(-1), active = activeState[0];
+  const items = React.useState([]);
+  const pos = React.useState(null);
+  const typed = React.useRef({ text: "", at: 0 });
+  const sync = React.useCallback(function() {
+    const el = selRef.current;
+    if (!el) return;
+    const o = el.selectedIndex >= 0 ? el.options[el.selectedIndex] : null;
+    const next = o ? { label: o.textContent || "", empty: o.value === "" } : { label: "", empty: true };
+    shown[1](function(cur) {
+      return cur.label === next.label && cur.empty === next.empty ? cur : next;
+    });
+  }, []);
+  const hook = React.useCallback(
+    function(el) {
+      selRef.current = el;
+      if (!el || native || el.__auraHooked) return;
+      el.__auraHooked = true;
+      const proto = HTMLSelectElement.prototype;
+      const pv = Object.getOwnPropertyDescriptor(proto, "value"), pi = Object.getOwnPropertyDescriptor(proto, "selectedIndex");
+      if (pv && pv.set && pv.get)
+        Object.defineProperty(el, "value", {
+          configurable: true,
+          get: function() {
+            return pv.get.call(el);
+          },
+          set: function(v) {
+            pv.set.call(el, v);
+            sync();
+          }
+        });
+      if (pi && pi.set && pi.get)
+        Object.defineProperty(el, "selectedIndex", {
+          configurable: true,
+          get: function() {
+            return pi.get.call(el);
+          },
+          set: function(v) {
+            pi.set.call(el, v);
+            sync();
+          }
+        });
+      el.focus = function(o) {
+        if (trigRef.current) trigRef.current.focus(o);
+        else proto.focus.call(el, o);
+      };
+    },
+    [native, sync]
+  );
+  const selMerged = useMergedRef(ref, hook);
+  React.useEffect(
+    function() {
+      const f = selRef.current && selRef.current.form;
+      if (!f || native) return;
+      function onReset() {
+        setTimeout(sync, 0);
+      }
+      f.addEventListener("reset", onReset);
+      return function() {
+        f.removeEventListener("reset", onReset);
+      };
+    },
+    [native, sync]
+  );
+  const focusedOnce = React.useRef(false);
+  React.useEffect(
+    function() {
+      if (!live || focusedOnce.current || !trigRef.current) return;
+      focusedOnce.current = true;
+      if (props.autoFocus || selRef.current && document.activeElement === selRef.current) trigRef.current.focus();
+    },
+    [live]
+  );
+  useIsoLayoutEffect(function() {
+    if (!live) return;
+    sync();
+    if (!open) return;
+    const now = readItems(selRef.current), was = items[0];
+    const same = now.length === was.length && now.every(function(it, i) {
+      const w = was[i];
+      return w.value === it.value && w.label === it.label && w.disabled === it.disabled && w.group === it.group;
+    });
+    if (same) return;
+    items[1](now);
+    if (!choices(now).length) {
+      close(false);
+      return;
+    }
+    const hv = was[active] ? was[active].value : null;
+    const again = now.filter(function(it) {
+      return !it.disabled && it.value === hv;
+    })[0];
+    const cur = selRef.current ? selRef.current.selectedIndex : -1;
+    activeState[1](again ? again.index : now[cur] && !now[cur].disabled ? cur : choices(now)[0].index);
+  });
+  function choices(list) {
+    return list.filter(function(i) {
+      return !i.disabled;
+    });
+  }
+  function choose(it) {
+    const el = selRef.current;
+    if (!el || it.disabled) return;
+    if (el.value !== it.value) {
+      el.value = it.value;
+      el.dispatchEvent(new Event("input", { bubbles: true }));
+      el.dispatchEvent(new Event("change", { bubbles: true }));
+    }
+    sync();
+    close(true);
+  }
+  function openList(at) {
+    if (props.disabled || trigRef.current && trigRef.current.disabled) return;
+    const list = readItems(selRef.current);
+    const ok = choices(list);
+    if (!ok.length) return;
+    items[1](list);
+    const cur = selRef.current ? selRef.current.selectedIndex : -1;
+    let a = at === "first" ? ok[0].index : at === "last" ? ok[ok.length - 1].index : cur;
+    if (typeof at === "number") a = at;
+    if (a < 0 || !list[a] || list[a].disabled) a = ok[0].index;
+    activeState[1](a);
+    openState[1](true);
+  }
+  function close(focus) {
+    openState[1](false);
+    pos[1](null);
+    if (focus && trigRef.current) trigRef.current.focus();
+  }
+  function step(from, dir, list) {
+    for (let i = from + dir; i >= 0 && i < list.length; i += dir) if (!list[i].disabled) return i;
+    return from;
+  }
+  function typing() {
+    return !!typed.current.text && Date.now() - typed.current.at < 500;
+  }
+  function typeahead(ch, list, from) {
+    const now = Date.now(), t = typed.current;
+    t.text = now - t.at < 500 ? t.text + ch : ch;
+    t.at = now;
+    const q = t.text.toLocaleLowerCase();
+    for (let k = 1; k <= list.length; k++) {
+      const i = (from + (t.text.length > 1 ? 0 : 1) + k - 1 + list.length) % list.length;
+      if (!list[i].disabled && list[i].label.toLocaleLowerCase().indexOf(q) === 0) return i;
+    }
+    t.text = "";
+    return -1;
+  }
+  function onKeyDown(e) {
+    const k = e.key;
+    const printable = k.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey;
+    const search = printable && (k !== " " || typing());
+    if (!open) {
+      if (search) {
+        const list2 = readItems(selRef.current);
+        const i = typeahead(k, list2, selRef.current ? selRef.current.selectedIndex : -1);
+        e.preventDefault();
+        if (i >= 0) openList(i);
+      } else if (k === "ArrowDown" || k === "ArrowUp" || k === "Enter" || k === " ") {
+        e.preventDefault();
+        openList(k === "ArrowUp" && !(selRef.current && selRef.current.value) ? "last" : void 0);
+      }
+      return;
+    }
+    const list = items[0];
+    if (search) {
+      e.preventDefault();
+      const i = typeahead(k, list, active);
+      if (i >= 0) activeState[1](i);
+    } else if (k === "ArrowDown") {
+      e.preventDefault();
+      activeState[1](step(active, 1, list));
+    } else if (k === "ArrowUp") {
+      e.preventDefault();
+      activeState[1](step(active, -1, list));
+    } else if (k === "Home" || k === "PageUp") {
+      e.preventDefault();
+      activeState[1](k === "Home" ? step(-1, 1, list) : Math.max(step(-1, 1, list), step(active - 9, 1, list)));
+    } else if (k === "End" || k === "PageDown") {
+      e.preventDefault();
+      activeState[1](
+        k === "End" ? step(list.length, -1, list) : Math.min(step(list.length, -1, list), step(active + 9, -1, list))
+      );
+    } else if (k === "Enter" || k === " ") {
+      e.preventDefault();
+      if (list[active]) choose(list[active]);
+    } else if (k === "Escape") {
+      e.preventDefault();
+      e.stopPropagation();
+      close(true);
+    } else if (k === "Tab") {
+      close(false);
+    }
+  }
+  useIsoLayoutEffect(
+    function() {
+      if (!open) return;
+      function place() {
+        const t = trigRef.current && trigRef.current.parentElement;
+        if (!t) return;
+        const r = t.getBoundingClientRect(), below = window.innerHeight - r.bottom - 8, above = r.top - 8, want = listRef.current ? listRef.current.scrollHeight : 320, up = below < Math.min(want, 200) && above > below;
+        pos[1]({
+          left: r.left,
+          width: r.width,
+          top: up ? void 0 : r.bottom + 4,
+          bottom: up ? window.innerHeight - r.top + 4 : void 0,
+          maxHeight: Math.min(320, (up ? above : below) - 4)
+        });
+      }
+      place();
+      function outside(e) {
+        const n = e.target;
+        if (listRef.current && listRef.current.contains(n)) return;
+        if (trigRef.current && trigRef.current.contains(n)) return;
+        close(false);
+      }
+      function onScroll(e) {
+        if (!listRef.current || !listRef.current.contains(e.target)) place();
+      }
+      document.addEventListener("pointerdown", outside, true);
+      window.addEventListener("scroll", onScroll, true);
+      window.addEventListener("resize", place);
+      return function() {
+        document.removeEventListener("pointerdown", outside, true);
+        window.removeEventListener("scroll", onScroll, true);
+        window.removeEventListener("resize", place);
+      };
+    },
+    [open]
+  );
+  React.useEffect(
+    function() {
+      if (!open || !listRef.current || active < 0) return;
+      const el = listRef.current.querySelector('[data-idx="' + active + '"]');
+      if (el && el.scrollIntoView) el.scrollIntoView({ block: "nearest" });
+    },
+    [open, active, pos[0] != null]
+  );
+  const described = [describedBy(id, props), rest["aria-describedby"]].filter(Boolean).join(" ") || void 0;
+  const field = (child) => /* @__PURE__ */ React.createElement(
     Field,
     {
       id,
+      labelId: native ? void 0 : id + "-label",
       label: props.label,
       hint: props.hint,
       error: props.error,
@@ -28,19 +331,180 @@ const Select = React.forwardRef(function Select2(props, ref) {
       disabled: props.disabled,
       className: props.className
     },
-    /* @__PURE__ */ React.createElement("div", { className: cx("aura-input aura-select", props.icon && "has-icon") }, props.icon ? /* @__PURE__ */ React.createElement(Icon, { name: props.icon, className: "aura-input__icon" }) : null, h(
-      "select",
-      Object.assign(extra, rest, {
-        ref,
-        id,
-        className: "aura-input__control",
-        required: props.required,
-        "aria-invalid": props.error ? true : void 0,
-        "aria-describedby": describedBy(id, props)
-      }),
-      opts,
-      props.children
-    ), /* @__PURE__ */ React.createElement(Icon, { name: "chevron-down", className: "aura-select__chevron" }))
+    child
+  );
+  if (!live)
+    return field(
+      /* @__PURE__ */ React.createElement("div", { className: cx("aura-input aura-select", props.icon && "has-icon") }, props.icon ? /* @__PURE__ */ React.createElement(Icon, { name: props.icon, className: "aura-input__icon" }) : null, h(
+        "select",
+        Object.assign(extra, rest, {
+          ref: native ? ref : selMerged,
+          id,
+          className: "aura-input__control",
+          required: props.required,
+          "aria-invalid": props.error ? true : void 0,
+          "aria-describedby": described
+        }),
+        opts,
+        props.children
+      ), /* @__PURE__ */ React.createElement(Icon, { name: "chevron-down", className: "aura-select__chevron" }))
+    );
+  const listId = id + "-list", labelId = id + "-label";
+  const optId = function(i) {
+    return id + "-opt-" + i;
+  };
+  const labelledBy = rest["aria-labelledby"] || (props.label ? labelId : void 0);
+  const selIndex = selRef.current ? selRef.current.selectedIndex : -1;
+  const option = function(it) {
+    const sel = selIndex === it.index;
+    return /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        key: it.index,
+        id: optId(it.index),
+        role: "option",
+        "data-idx": it.index,
+        "aria-selected": sel,
+        "aria-disabled": it.disabled || void 0,
+        className: cx(
+          "aura-combo__option",
+          it.index === active && "is-active",
+          sel && "is-selected",
+          it.disabled && "is-disabled"
+        ),
+        onPointerDown: function(e) {
+          e.preventDefault();
+        },
+        onPointerMove: function() {
+          if (!it.disabled && active !== it.index) activeState[1](it.index);
+        },
+        onClick: function() {
+          choose(it);
+        }
+      },
+      /* @__PURE__ */ React.createElement("span", { className: "aura-combo__text" }, /* @__PURE__ */ React.createElement("span", { className: "aura-combo__label" }, it.label)),
+      sel ? /* @__PURE__ */ React.createElement(Icon, { name: "check", className: "aura-combo__check" }) : null
+    );
+  };
+  const runs = [];
+  items[0].forEach(function(it) {
+    if (it.value === "" && it.disabled) return;
+    const last = runs[runs.length - 1];
+    if (last && last.group === it.group) last.items.push(it);
+    else runs.push({ group: it.group, items: [it] });
+  });
+  const popup = open ? createPortal(
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        ref: listRef,
+        "data-density": density,
+        className: "aura-combo__popover aura-select__popover",
+        style: pos[0] ? {
+          left: pos[0].left,
+          minWidth: pos[0].width,
+          top: pos[0].top,
+          bottom: pos[0].bottom,
+          maxHeight: pos[0].maxHeight
+        } : { left: -9999, top: -9999 }
+      },
+      /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          id: listId,
+          role: "listbox",
+          "aria-labelledby": labelledBy,
+          "aria-label": labelledBy ? void 0 : rest["aria-label"],
+          className: "aura-combo__list"
+        },
+        runs.map(function(r, n) {
+          if (r.group === null) return /* @__PURE__ */ React.createElement(React.Fragment, { key: "r" + n }, r.items.map(option));
+          const gid = id + "-group-" + n;
+          return /* @__PURE__ */ React.createElement("div", { key: "r" + n, role: "group", "aria-labelledby": gid }, /* @__PURE__ */ React.createElement("div", { id: gid, className: "aura-select__group" }, r.group), r.items.map(option));
+        })
+      )
+    ),
+    document.body
+  ) : null;
+  const userFocus = rest.onFocus, userBlur = rest.onBlur, userKey = rest.onKeyDown, userClick = rest.onClick;
+  return field(
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        className: cx("aura-input aura-select aura-select--custom", props.icon && "has-icon", open && "is-open"),
+        "data-invalid": props.error ? "" : void 0
+      },
+      props.icon ? /* @__PURE__ */ React.createElement(Icon, { name: props.icon, className: "aura-input__icon" }) : null,
+      h(
+        "select",
+        Object.assign(extra, pick(rest, FORM_KEYS), {
+          ref: selMerged,
+          id: id + "-select",
+          className: "aura-select__native",
+          tabIndex: -1,
+          "aria-hidden": true,
+          required: props.required,
+          onChange: function(e) {
+            sync();
+            if (props.onChange) props.onChange(e);
+          },
+          /* A browser focusing the <select> (the required bubble, a label click) hands focus to the button. */
+          onFocus: function() {
+            if (trigRef.current) trigRef.current.focus();
+          },
+          /* Only the blur the button reports (below): the <select>'s own, while it hands focus over, is not one. */
+          onBlur: function(e) {
+            if (!e.nativeEvent.isTrusted && userBlur) userBlur(e);
+          }
+        }),
+        opts,
+        props.children
+      ),
+      /* @__PURE__ */ React.createElement(
+        "button",
+        {
+          ...omit(rest, HANDLED_KEYS),
+          ref: trigRef,
+          type: "button",
+          role: "combobox",
+          form: id + "-no-form",
+          className: "aura-input__control aura-select__trigger",
+          disabled: props.disabled,
+          tabIndex: rest.tabIndex,
+          "aria-haspopup": "listbox",
+          "aria-expanded": open,
+          "aria-controls": open ? listId : void 0,
+          "aria-activedescendant": open && active >= 0 ? optId(active) : void 0,
+          id,
+          "aria-label": rest["aria-label"],
+          "aria-labelledby": rest["aria-labelledby"],
+          "aria-required": props.required || void 0,
+          "aria-invalid": props.error ? true : void 0,
+          "aria-describedby": described,
+          onFocus: function(e) {
+            if (userFocus) userFocus(e);
+          },
+          onClick: function(e) {
+            if (userClick) userClick(e);
+            if (e.defaultPrevented) return;
+            if (open) close(true);
+            else openList();
+          },
+          onKeyDown: function(e) {
+            if (userKey) userKey(e);
+            if (!e.defaultPrevented) onKeyDown(e);
+          },
+          onBlur: function(e) {
+            if (listRef.current && e.relatedTarget && listRef.current.contains(e.relatedTarget)) return;
+            if (open) close(false);
+            if (selRef.current) selRef.current.dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
+          }
+        },
+        /* @__PURE__ */ React.createElement("span", { id: id + "-value", className: cx("aura-select__value", shown[0].empty && "is-placeholder") }, shown[0].label || " ")
+      ),
+      /* @__PURE__ */ React.createElement(Icon, { name: "chevron-down", className: "aura-select__chevron" }),
+      popup
+    )
   );
 });
 export {

package/dist/index.d.cts

@@ -46,6 +46,11 @@ export interface DataTableState {
 	sort: DataTableSort | null;
 	page: number;
 }
+/** A callback that gets one row. Written with your own row type (`(r: Order) => …`) it still fits (5.4):
+ * the row is checked the way method parameters are, so no cast from `Record<string, any>` is needed. */
+export type RowCallback<R> = {
+	bivarianceHack(row: Record<string, any>): R;
+}["bivarianceHack"];
 export interface DataTableColumn {
 	/** Key into each row object. */
 	key: string;
@@ -62,9 +67,9 @@ export interface DataTableColumn {
 	/** Header becomes a button cycling asc → desc → unsorted. */
 	sortable?: boolean | undefined;
 	/** Value to sort by, when not the cell value (dates, amounts). */
-	sortValue?: ((row: Record<string, any>) => string | number | null) | undefined;
+	sortValue?: RowCallback<string | number | null> | undefined;
 	/** Custom cell content. */
-	render?: ((row: Record<string, any>) => React$1.ReactNode) | undefined;
+	render?: RowCallback<React$1.ReactNode> | undefined;
 	/** Set false to keep a sized column fixed when the table is `resizable`. */
 	resizable?: boolean | undefined;
 	/** Resize limits in px. Defaults 64 / 480. For the flexible column, minWidth defaults to 160. */
@@ -98,7 +103,9 @@ export interface DataTableEmpty {
 export interface DataTableProps {
 	/** Defaults to ID · NAME · STATUS · OWNER (96 / 160 / 112 / auto px). */
 	columns?: DataTableColumn[] | undefined;
-	rows: Array<Record<string, React$1.ReactNode>>;
+	/** Row objects. Any typed interface works (5.4: before, `interface Order {…}` rows needed a cast); cells show
+	 * the value at each column's key unless the column has `render`. */
+	rows: ReadonlyArray<Record<string, any>>;
 	/** Column key giving each row a unique React key. Default: the first column's key. */
 	rowKey?: string | undefined;
 	/** Accessible name for the table. */
@@ -145,7 +152,7 @@ export interface DataTableProps {
 	totalRows?: number | undefined;
 	/** Makes each row a link: the first column's content renders as the provider's linkComponent (or `<a>`), and a click
 	 * or Enter anywhere on the row follows it. Ctrl/⌘-click opens a new tab as usual. */
-	getRowHref?: ((row: Record<string, any>) => string) | undefined;
+	getRowHref?: RowCallback<string> | undefined;
 	/** Pager arrows become links to these URLs (search-param paging). Without onPageChange the link navigates. */
 	getPageHref?: ((page: number) => string) | undefined;
 	/** Router link for getRowHref / getPageHref. Default: AuraProvider's linkComponent, else `<a>`. */
@@ -153,7 +160,7 @@ export interface DataTableProps {
 	/** Skeleton row count when there is no pageSize. Default 5. */
 	skeletonRows?: number | undefined;
 	/** Called on row click or Enter. */
-	onRowActivate?: ((row: Record<string, any>) => void) | undefined;
+	onRowActivate?: RowCallback<void> | undefined;
 	/** Fixed height in px: sticky header, and only the rows in view are rendered. */
 	height?: number | undefined;
 	/** Column menu on every header, drag-to-reorder, and the show/hide columns button. */
@@ -321,11 +328,14 @@ export interface FormErrorItem {
 	message: React$1.ReactNode;
 }
 /** The list of problems at the top of a form after a failed submit; each links to its field (GOV.UK pattern). */
+/** react-hook-form's `formState.errors` (FieldErrors) or any object shaped like it: a `message` at any depth. */
+export type FormErrorTree = {
+	readonly [field: string]: object | undefined;
+};
 export interface FormErrorSummaryProps {
-	/** A list, or react-hook-form's `formState.errors` as is (`{ name: { message } }`). Empty → renders nothing. */
-	errors: FormErrorItem[] | Record<string, {
-		message?: React$1.ReactNode | undefined;
-	} | undefined>;
+	/** A list, or react-hook-form's `formState.errors` as is: `{ name: { message } }`, nested for `address.street`
+	 * and field arrays (`items.0.name`). Empty → renders nothing. */
+	errors: FormErrorItem[] | FormErrorTree;
 	/** Default "Fix N fields to continue" in the provider's language. */
 	title?: React$1.ReactNode | undefined;
 	/** Called with the field when a link is followed, e.g. react-hook-form's `setFocus`. Default: focus the element whose id (or name) is the field. */
@@ -417,9 +427,15 @@ export type SelectOption = string | {
 	label: string;
 	disabled?: boolean | undefined;
 };
-export interface SelectProps extends FieldProps, Omit<React$1.SelectHTMLAttributes<HTMLSelectElement>, "required"> {
-	options: SelectOption[];
-	/** A disabled first option shown in fg-tertiary until something is chosen. */
+/** 5.3: opens AURA's own list (light and dark alike) over a real `<select>`, which keeps `name`, `required`, the ref,
+ * `onChange`, react-hook-form `register` and form posts. `multiple` or `size > 1` keeps the native list box. */
+export interface SelectProps extends Omit<FieldProps, "label">, Omit<React$1.SelectHTMLAttributes<HTMLSelectElement>, "required"> {
+	/** Visible label; also the accessible name. Omit only with `aria-label` or `aria-labelledby` (a toolbar, a table
+	 * cell); development builds warn when the field has no name at all. */
+	label?: string | undefined;
+	/** The choices; or pass `<option>` / `<optgroup>` children instead (5.3: optional). */
+	options?: SelectOption[] | undefined;
+	/** Shown in fg-tertiary on the closed field until something is chosen; not listed as a choice. */
 	placeholder?: string | undefined;
 	icon?: IconInput | undefined;
 }
@@ -1217,6 +1233,7 @@ export interface FieldComponentProps extends Omit<FieldPropsPublic, "label"> {
 export declare const Field: React$1.ForwardRefExoticComponent<FieldComponentProps & React$1.RefAttributes<HTMLDivElement>>;
 export declare const TextField: React$1.ForwardRefExoticComponent<TextFieldProps & React$1.RefAttributes<HTMLInputElement>>;
 export declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
+/** A select field: a button that opens an AURA list (5.3), over a real <select> that keeps forms, refs and events. */
 export declare const Select: React$1.ForwardRefExoticComponent<SelectProps & React$1.RefAttributes<HTMLSelectElement>>;
 export declare const RadioGroup: React$1.ForwardRefExoticComponent<RadioGroupProps & React$1.RefAttributes<HTMLFieldSetElement>>;
 export declare const Switch: React$1.ForwardRefExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>;