@object-ui/fields 17.5.0 → 17.6.0

package/dist/widgets/TagsField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * TagsField - free-form list of string tags. Type a value and press Enter (or
  * comma) to add it; click a tag's × to remove it. The stored value is a

package/dist/widgets/TextAreaField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * TextAreaField - Multi-line text input widget
  * Supports configurable row count and preserves whitespace in readonly mode.
@@ -35,7 +35,11 @@ import { FieldWidgetComponentProps } from './types';
  * ## The character counter (objectui#3408, shared across surfaces in #3417)
  *
  * Both editing surfaces below — the inline `<Textarea>` and the fullscreen
- * dialog's — render the SAME `CharacterCount`, which owns the three-node
+ * dialog's — render the SAME `CharacterCount`. It lives in
+ * `@object-ui/components` since objectui#3439, hoisted there so the form
+ * renderer's built-in `textarea` branch renders that very component too rather
+ * than growing a third copy; this widget's use of it is unchanged. It owns the
+ * three-node
  * GOV.UK shape (decorative digits / accessible description / gated status
  * region) and the debounce and threshold behind it. Until #3417 the fullscreen
  * footer had its own hand-written copy that was digits and nothing else, which

package/dist/widgets/TextField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * TextField - Standard single-line or multi-line text input
  * Automatically renders as a textarea when rows are configured in field metadata

package/dist/widgets/TimeField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * TimeField - Time picker input widget
  * Uses native time input for hour and minute selection

package/dist/widgets/UrlField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * UrlField - URL input with clickable link in readonly mode
  * Validates URLs to only render http/https links for security

package/dist/widgets/UserField.d.ts

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 export declare function UserField(props: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/VectorField.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './types';
+import { FieldWidgetComponentProps } from './types.js';
 /**
  * VectorField - Vector/embedding data display
  * Shows vector embeddings in a read-only format

package/dist/widgets/_cell-renderer-bridge.d.ts

@@ -1,3 +1,3 @@
-import { CellRendererResolver } from './RecordPickerDialog';
+import { CellRendererResolver } from './RecordPickerDialog.js';
 export declare function setCellRendererResolver(resolver: CellRendererResolver): void;
 export declare function getCellRendererResolver(): CellRendererResolver | undefined;

package/dist/widgets/address-format.d.ts

@@ -52,17 +52,37 @@ export type LegacyAddressValue = AddressValue & {
 /** Postal code of a stored address, preferring the canonical key. */
 export declare function readPostalCode(addr: AddressValue): string | undefined;
 /**
- * Formats a stored address as a single line: `Street, City, State ZIP, Country`.
+ * Formats a stored address as a single line, in the part order the reader's
+ * locale writes addresses in.
  *
- * Ordering and separators are NOT invented here — they are the rule
- * `AddressField` already applied in its readonly branch, and the sub-field set
- * its inputs expose (street / city / state / postalCode / country). Missing
- * parts are dropped rather than spaced over, so a street-only address is
- * `"中策路 1 号"` and never `", , ,"`.
+ * Two orders, and the second is exactly the first reversed:
+ *
+ *   - **small-to-large** (default; `en` and every Latin/Cyrillic/Arabic locale
+ *     this repo ships) — `Street, City, State ZIP, Country`. Unchanged from
+ *     what `AddressField`'s readonly branch has always produced, so English and
+ *     provider-less rendering are byte-identical to before.
+ *   - **large-to-small** ({@link LARGE_TO_SMALL_LANGUAGES}) — `Country, ZIP
+ *     State, City, Street`. A `zh` console rendering a Chinese address
+ *     largest-first is the whole point of objectui#4028: `中国, 310000 浙江,
+ *     杭州, 中策路 1 号` rather than the US-ordered line it produced before.
+ *
+ * Only the ORDER varies. The separator stays `', '` in both, because that is
+ * not what the issue reports and because these lines carry mixed-script data —
+ * a US address read on a `zh` console would look stranger under fullwidth
+ * punctuation than under the comma it already has.
+ *
+ * The state/postal-code pair keeps its one comma-delimited group in both
+ * orders, space-separated inside it ("CA 94102" / "310000 浙江"); either part
+ * alone occupies the group by itself. Missing parts are dropped rather than
+ * spaced over, so a street-only address is `"中策路 1 号"` and never `", , ,"`.
  *
  * Returns `''` when no part is usable — callers decide what an empty address
  * looks like (an `EmptyValue` placeholder for the cell renderer), and a value
  * carrying no recognized part at all is NOT silently blanked: see
  * `AddressCellRenderer`, which falls back to JSON so unknown data stays visible.
+ *
+ * @param locale - BCP-47 tag from `useDisplayLocale()`. Omitted (tests, and any
+ *   caller with no React context) means the small-to-large default, which is
+ *   what this function did unconditionally before objectui#4028.
  */
-export declare function formatAddress(addr: AddressValue): string;
+export declare function formatAddress(addr: AddressValue, locale?: string): string;

package/dist/widgets/lookupColumnDisplay.d.ts

@@ -0,0 +1,93 @@
+import { default as React } from 'react';
+import { LookupColumnDef } from '@object-ui/types';
+/**
+ * Cell renderer function signature — matches `getCellRenderer` from
+ * `@object-ui/fields`. Re-declared here (rather than imported from
+ * RecordPickerDialog) so this module sits BELOW both consumers in the import
+ * graph and neither surface can pull the other in.
+ */
+export type LookupCellRendererResolver = (fieldType: string) => React.FC<{
+    value: any;
+    field: any;
+}>;
+/**
+ * A select option as the object schema declares it — `{ value, label }` plus
+ * whatever the renderer also reads (`color`, …), which the i18n translation
+ * carries through untouched.
+ */
+export type SchemaOption = {
+    value: any;
+    label: string;
+    [key: string]: any;
+};
+/** Translate a schema field's options through the shared i18n option path. */
+export type OptionTranslator = (objectName: string, fieldName: string, options: SchemaOption[]) => SchemaOption[];
+/**
+ * Normalise a lookup_columns entry (string | LookupColumnDef) into a
+ * concrete LookupColumnDef object.
+ */
+export declare function normalizeColumn(col: string | LookupColumnDef): LookupColumnDef;
+/**
+ * Pretty-print a field name as a column header label.
+ * Converts snake_case / camelCase to Title Case.
+ */
+export declare function fieldToLabel(field: string): string;
+/**
+ * Resolve a field's select options from the referenced object's schema field
+ * definition (`fieldsMeta[field]`), translated through the shared i18n option
+ * path.
+ *
+ * This is the SINGLE source for every surface that needs option labels: the
+ * picker table cells (#3333), the picker's filter panel select inputs (#3336)
+ * and the inline dropdown's option preview (#5492) — so a picker column, the
+ * filter input for that same column and the dropdown row can never disagree
+ * about what an option is called.
+ *
+ * Returns `undefined` when the schema field declares no options: a select
+ * field with no authored options genuinely has nothing to offer, and
+ * synthesising entries from the loaded page's raw stored values would paper
+ * over the metadata gap with a list that changes per page.
+ */
+export declare function resolveSchemaOptions(meta: {
+    options?: unknown;
+} | undefined, objectName: string, fieldName: string, translateOptions: OptionTranslator): SchemaOption[] | undefined;
+/**
+ * Field descriptors handed to the type-aware cell renderers, enriched from the
+ * referenced object's schema (`fieldsMeta`) the same way the list view enriches
+ * its columns. This is what lets a `select` column resolve its option label
+ * (options + i18n) instead of title-casing the raw value (#3333), and what
+ * carries `reference` / `reference_to` through to the lookup cell renderer so
+ * an unresolved foreign-key id resolves to a name (#5492).
+ *
+ * Columns whose def carries no `type` inherit the schema field's type, so
+ * string-authored `lookup_columns` format identically to object-authored ones.
+ */
+export declare function buildLookupColumnDescriptors(columns: LookupColumnDef[], fieldsMeta: Record<string, any> | undefined, objectName: string, translateOptions: OptionTranslator): Record<string, any>;
+export interface LookupColumnRenderContext {
+    /** Field descriptors from {@link buildLookupColumnDescriptors}. */
+    descriptors: Record<string, any>;
+    /** Type-aware renderer resolver; when absent every cell degrades to text. */
+    cellRenderer?: LookupCellRendererResolver;
+    /** The referenced object's `titleFormat`, applied to the display column. */
+    titleFormat?: string | null;
+    /** The lookup's display field — the column the title template stands in for. */
+    displayField?: string;
+    /** Locale for the plain-text `$date` fallback. */
+    displayLocale?: string;
+}
+/**
+ * Render one column of one candidate record.
+ *
+ * Order:
+ *   1. `titleFormat` template, for the display column only — so users see a
+ *      human-readable name instead of a raw id when the display field
+ *      (commonly defaulted to `name`) does not exist on the record.
+ *   2. the type-aware cell renderer for the column's field descriptor.
+ *   3. a plain-text fallback for columns with no descriptor / no resolver.
+ *
+ * Step 3 never blanks a populated value: an object with no recognised shape
+ * keeps its JSON and a primitive keeps its `String()` form. That floor is
+ * deliberate — an unresolved reference showing its bare id is strictly better
+ * than a silently empty column (objectui#5492).
+ */
+export declare function renderLookupColumnValue(record: any, col: LookupColumnDef, ctx: LookupColumnRenderContext): React.ReactNode;

package/dist/widgets/richTextDisplay.d.ts

@@ -0,0 +1,80 @@
+import { default as React } from 'react';
+import { CellRendererProps } from '../index.js';
+/**
+ * Renders `markdown` values as formatted GFM markdown (lazy-loaded, sanitized)
+ * instead of the raw markup string.
+ *
+ * Markdown ONLY. `MarkdownContent` runs react-markdown with no `rehype-raw`, so
+ * raw HTML in the string is not parsed and never reaches the DOM — that is this
+ * renderer's trust boundary, not an oversight, and it must stay that way
+ * (objectui#5452). `richtext` used to be routed here too and rendered as a
+ * COMPLETELY EMPTY cell, because a richtext value is entirely HTML and this
+ * pipeline drops all of it; see {@link HtmlCellRenderer}, which is where that
+ * type belongs. Loosening this pipeline to pass raw HTML through would have
+ * "fixed" one type by moving every `markdown` cell's trust boundary.
+ */
+export declare function MarkdownCellRenderer({ value }: CellRendererProps): React.ReactElement;
+/**
+ * Renders an `html` value as sanitized, formatted HTML instead of raw markup.
+ *
+ * Also the renderer for `richtext` (objectui#5452). Both types store an HTML
+ * string: the spec's `Field.richtext` is documented as "Formatted content with
+ * HTML/WYSIWYG", the showcase seed's own specimen is
+ * `<p>Rich <strong>text</strong></p>`, and this repo's designer bridge already
+ * maps `richtext` onto its `html` type. {@link sanitizeHtml} above removes
+ * script/style/iframe/object/embed blocks, inline event handlers and
+ * `javascript:` URLs, and touches nothing a rich-text editor legitimately
+ * emits — headings, paragraphs, emphasis, lists, links, quotes all survive, so
+ * routing `richtext` here restores the content rather than trading a blank cell
+ * for a mangled one.
+ */
+export declare function HtmlCellRenderer({ value }: CellRendererProps): React.ReactElement;
+/**
+ * Field type → display pipeline, for the three types `RichTextField` serves.
+ *
+ * THE table, singular. `getCellRenderer`'s standard map spreads it (so the
+ * grid, kanban, gallery, related list, dashboard panel and detail read mode
+ * resolve through these entries) and `RichTextField`'s readonly branch indexes
+ * it (so a readonly form field renders through the very same component). A
+ * change here moves every read surface at once; there is no second copy left
+ * to forget.
+ *
+ * `richtext` reads through the HTML renderer — NOT the markdown one, which
+ * drops raw HTML and therefore rendered every populated richtext value as a
+ * blank cell (objectui#5452).
+ */
+export declare const RICH_TEXT_CELL_RENDERERS: {
+    readonly markdown: typeof MarkdownCellRenderer;
+    readonly html: typeof HtmlCellRenderer;
+    readonly richtext: typeof HtmlCellRenderer;
+};
+/** The rich-content field types, i.e. the keys of {@link RICH_TEXT_CELL_RENDERERS}. */
+export type RichTextFieldType = keyof typeof RICH_TEXT_CELL_RENDERERS;
+/**
+ * The SYNTAX a rich-content type stores, derived from the renderer that type
+ * resolves to rather than declared a second time.
+ *
+ * This is what `RichTextField`'s editor header names ("Format: markdown"), and
+ * deriving it from {@link RICH_TEXT_CELL_RENDERERS} is the point: the header
+ * used to be computed as `field.format || 'markdown'`, and since `format` is
+ * declared on no rich-content field type (only on `date`/`datetime`/`time`/
+ * `phone`/`auto_number`), it read `undefined` for every real field and labelled
+ * an `html` field "Format: markdown" — a label pointing at a pipeline the value
+ * does not go through. Derived, the label cannot disagree with the renderer.
+ *
+ * `undefined` for a type with no pipeline, rather than a guessed default: the
+ * caller has to say what it does with "not a rich-content type" instead of
+ * silently getting the markdown answer, which is the bug this replaces.
+ */
+export declare function richTextSyntax(fieldType: string): 'markdown' | 'html' | undefined;
+/**
+ * The display pipeline a field type reads through, or `undefined` when the
+ * type is not one of the three rich-content types.
+ *
+ * The lookup is a function rather than a raw index so the "not a rich-content
+ * type" answer is in the RETURN TYPE. Indexing {@link RICH_TEXT_CELL_RENDERERS}
+ * directly hands back a non-optional component for any key the caller casts,
+ * so the miss becomes a runtime `undefined` the compiler has been told cannot
+ * happen — and a caller that checks for it reads as dead code.
+ */
+export declare function richTextCellRenderer(fieldType: string): React.FC<CellRendererProps> | undefined;

package/dist/widgets/toHostGroupProps.d.ts

@@ -7,19 +7,21 @@
  */
 /**
  * The props that make a group-labelled widget's rendered surface the thing its
- * host label actually NAMES, on the surfaces that are not controls
- * (objectui#3990).
+ * host label actually NAMES — and, where nothing else can carry it, DESCRIBES
+ * (objectui#3990, objectui#4005).
  *
  * ## What it is for
  *
  * A widget declared `labelling: 'group'` (objectui#3961) is told by the form
  * renderer: your label publishes an `id` and drops its `for`, so name yourself
- * by IDREF. The renderer hands down exactly two facts that address the field as
- * a WHOLE:
+ * by IDREF. The renderer hands down facts that address the field as a WHOLE:
  *
  *  - `id` — the host's control id (`…-form-item`), the id the label's `for`
  *    used to point at;
- *  - `aria-labelledby` — the IDREF of that visible label.
+ *  - `aria-labelledby` — the IDREF of that visible label;
+ *  - `aria-describedby` — the IDREF of `<FormDescription>`, the field's visible
+ *    help text. Which surface may consume it is the one thing that is NOT
+ *    uniform, so it is decided per call site — see {@link HostGroupSurface}.
  *
  * Every editable branch already consumes them inside its wider `toDomProps`
  * spread. The branches that returned EARLY did not — a field-level
@@ -39,19 +41,66 @@
  * to nothing can at least be swept for, while "a label published an id and
  * nobody consumed it" looks like healthy markup.
  *
- * ## Why this narrow pair, and not the whole `toDomProps` result
+ * ## The description was the other half of the same defect (objectui#4005)
  *
- * Everything else in the DOM pass-through addresses a CONTROL, and a readonly
- * display has none: `aria-describedby` / `aria-required` are announced when
- * focus lands on something focusable, `disabled` / `tabIndex` / the focus
- * handlers only mean something on an interactive element, and `name` is
- * DOM-legal on form controls only — on a `div` it is exactly the leak
- * objectui#3291 sweeps for. Spreading the full result would also put the host's
- * `className` on top of the widget's own, because the widgets whose readonly
- * surface is a placeholder or a plain container (`EmptyValue`, `FileField`,
- * `AddressField`) keep `className` inside `props`.
+ * #3990 landed the `id` + `aria-labelledby` pair above and deliberately stopped
+ * there. The reasoning it recorded — a readonly display has no focusable
+ * control, and `aria-describedby` is announced when focus lands on something
+ * focusable — was the right call for the surface as it stood THEN: before this
+ * helper existed, a readonly branch had no role at all, and on a role-less
+ * `div` / `span` an `aria-describedby` is as inert as the `aria-labelledby`
+ * was. That premise expired the moment #3990 gave those surfaces
+ * `role="group"`. A group IS a description carrier under ARIA 1.2: assistive
+ * technology announces a group's name and description on entering it, with no
+ * focusable control required. So the help text stayed measurably unreachable
+ * for exactly as long as it took to have somewhere to put it. Measured on
+ * `origin/main` at `c25222758`, a real form, one field per row, counting the
+ * elements whose `aria-describedby` names the rendered `<FormDescription>`:
  *
- * ## Why `role` travels with the two keys
+ * ```
+ *                                    descEl  consumers  consumerTags
+ * address      editable   desc=YES   SET         1      [input]
+ * address      readonly   desc=YES   SET         0      []
+ * geolocation  editable   desc=YES   SET         1      [input]
+ * geolocation  readonly   desc=YES   SET         0      []
+ * checkboxes   editable   desc=YES   SET         1      [div[group]]
+ * checkboxes   readonly   desc=YES   SET         0      []
+ * radio        editable   desc=YES   SET         1      [div[radiogroup]]
+ * radio        readonly   desc=YES   SET         0      []
+ * rating       editable   desc=YES   SET         1      [div[group]]
+ * rating       readonly   desc=YES   SET         0      []
+ * file         editable   desc=YES   SET         1      [div[button]]
+ * file         readonly   desc=YES   SET         0      []
+ * multiselect  editable   desc=YES   SET         1      [div[group]]
+ * multiselect  readonly   desc=YES   SET         0      []
+ * ```
+ *
+ * All seven render the `<FormDescription>` in the readonly state — none is
+ * exempt for want of one — and all seven left it referenced by nothing.
+ *
+ * ## What still does NOT come along, and why that is a boundary and not an oversight
+ *
+ * `aria-invalid` and `aria-required` are CONTROL-channel state: they report
+ * what a user's own editing may do wrong, to the element they would edit. A
+ * readonly display cannot be edited and cannot be made invalid by the person
+ * reading it, so putting either on it announces a state that has no action
+ * behind it. Spreading the whole `toDomProps` result would drag both back —
+ * along with `disabled` / `tabIndex` / the focus handlers, which only mean
+ * something on an interactive element, and `name`, which is DOM-legal on form
+ * controls only and on a `div` is exactly the leak objectui#3291 sweeps for.
+ * That is what objectui#3291 and objectui#3318 drew the line against, and
+ * adding the description does not move it: the description is what the FIELD
+ * is, the other two are what the CONTROL is doing. The line is pinned from both
+ * sides in `composite-group-label-readonly-e2e.test.tsx` — the description must
+ * be there, `aria-invalid` / `aria-required` must not — so neither a later
+ * "spread it all" nor a later "take it all back out" can pass quietly.
+ *
+ * Spreading the full result would also put the host's `className` on top of the
+ * widget's own, because the widgets whose readonly surface is a placeholder or
+ * a plain container (`EmptyValue`, `FileField`, `AddressField`) keep
+ * `className` inside `props`.
+ *
+ * ## Why `role` travels with the keys
  *
  * `aria-labelledby` on a role-less `div` / `span` names NOTHING — `generic`
  * prohibits an author name — so the pair is inert without a role that supports
@@ -73,19 +122,68 @@ export interface HostGroupProps {
     id?: string;
     /** IDREF of the host's visible label. */
     'aria-labelledby'?: string;
+    /**
+     * IDREF of the host's visible help text — present only on a surface that
+     * renders no input of the field's own. See {@link HostGroupSurface}.
+     */
+    'aria-describedby'?: string;
     /** `'group'` when — and only when — a host named this surface. */
     role?: 'group';
 }
 /**
- * Read the two whole-field keys out of a widget's leftover props, plus the role
- * that makes them mean something. See {@link HostGroupProps}.
+ * WHERE the surface being named sits relative to the field's own inputs. The
+ * name is uniform; the DESCRIPTION is not, so every call site has to say which
+ * of the two shapes it is, and the compiler makes the next widget author say it
+ * too rather than inherit whichever default happened to be there.
+ *
+ *  - `'above-the-inputs'` — a composite's EDITABLE container (`address`,
+ *    `geolocation`): the field's real inputs are inside it and each already
+ *    receives `aria-describedby` in its own `toDomProps` spread, straight from
+ *    `<FormControl>`'s Slot. This surface therefore takes the NAME only.
+ *    objectui#3318 chose that split deliberately and
+ *    `composite-group-label-e2e.test.tsx` pins it: the help text is announced
+ *    when focus reaches the box the user types into, and announcing it a second
+ *    time on the container that merely wraps those boxes is a double channel of
+ *    exactly the kind objectui#3290 removed from the required marker.
+ *
+ *  - `'instead-of-the-inputs'` — every readonly branch, and the zero-option box
+ *    (`OptionsEmptyState`). The field renders no input at all here, so no
+ *    element inside can carry the description and this surface is the only
+ *    candidate there is. It takes the name AND the description.
+ *
+ * Note what the discriminator is NOT about: whether the surface contains
+ * anything focusable. `geolocation`'s readonly row holds a "View on map" link
+ * — focusable, and correctly announced as itself. It is not an input OF THE
+ * FIELD and never receives the field's `aria-describedby`, so that row is still
+ * `'instead-of-the-inputs'`.
+ */
+export type HostGroupSurface = 'above-the-inputs' | 'instead-of-the-inputs';
+/**
+ * Read the whole-field keys out of a widget's leftover props, plus the role
+ * that makes them mean something. See {@link HostGroupProps} and
+ * {@link HostGroupSurface}.
  *
  * Routed through {@link toDomProps} rather than reading `props` directly so the
- * pair keeps ONE gate: those keys reach an element only if the DOM pass-through
- * whitelist still forwards them, and its two compile-time assertions bind that
+ * keys keep ONE gate: they reach an element only if the DOM pass-through
+ * whitelist still forwards them, and its compile-time assertions bind that
  * whitelist to the props contract in both directions.
+ *
+ * `aria-describedby` is forwarded exactly as the host handed it down, with no
+ * check that it resolves — a widget cannot see whether `<FormDescription>`
+ * rendered, and a DOM probe for it would be a layout-effect hack around the
+ * renderer's own knowledge. That is not a new gap: `<FormControl>`'s Slot emits
+ * the IDREF unconditionally, so a field with NO description already hands every
+ * editable control an `aria-describedby` pointing at an element that does not
+ * exist. Measured on `origin/main` at `c25222758`, `desc=NO`: all seven
+ * group-labelled widgets plus the builtin `input` and the single-control
+ * `email` carry exactly one such reference, on the same element that would
+ * carry a resolving one. A readonly surface answering identically is parity
+ * with the editable branch, not a class of its own — and an IDREF that resolves
+ * to nothing is inert for assistive technology, where an unconsumed
+ * description is simply lost.
  */
 export declare function toHostGroupProps(props: {
     id?: string;
     'aria-labelledby'?: string;
-}): HostGroupProps;
+    'aria-describedby'?: string;
+}, surface: HostGroupSurface): HostGroupProps;

package/dist/widgets/types.d.ts

@@ -157,9 +157,14 @@ export type FieldWidgetComponentProps<T = any> = {
     onUploadingChange?: (uploading: boolean) => void;
     /**
      * DataSource for widgets that query records (lookup / user / object-ref /
-     * recipient-picker / grid). Injected by the form renderer for the field
-     * types that need it, and passed directly by inline-edit hosts. Option
-     * widgets destructure it purely to keep it off their DOM spread.
+     * recipient-picker). Injected by the form renderer for the field types that
+     * need it, and passed directly by inline-edit hosts. Option widgets
+     * destructure it purely to keep it off their DOM spread.
+     *
+     * `grid` was listed here with zero consumers (objectui#4814): `GridField.tsx`
+     * never reads `dataSource`, and no data-source table has ever contained the
+     * key, so the claim described a wiring that did not exist. `owner` is absent
+     * for a different reason — the spelling itself is retired (same card).
      *
      * Left structural (`unknown`): `@object-ui/fields` must not depend on a
      * concrete adapter — every consumer narrows it itself.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/fields",
-  "version": "17.5.0",
+  "version": "17.6.0",
   "description": "Field renderers and registry for Object UI",
   "license": "MIT",
   "type": "module",
@@ -18,25 +18,24 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@objectstack/spec": "^17.0.0-rc.6",
+    "@objectstack/spec": "^17.0.0",
     "clsx": "^2.1.1",
-    "lucide-react": "^1.29.0",
+    "lucide-react": "^1.31.0",
     "react-markdown": "^10.1.0",
     "rehype-sanitize": "^6.0.0",
     "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.6.0",
-    "@object-ui/components": "17.5.0",
-    "@object-ui/core": "17.5.0",
-    "@object-ui/i18n": "17.5.0",
-    "@object-ui/providers": "17.5.0",
-    "@object-ui/react": "17.5.0",
-    "@object-ui/types": "17.5.0"
+    "@object-ui/components": "17.6.0",
+    "@object-ui/core": "17.6.0",
+    "@object-ui/i18n": "17.6.0",
+    "@object-ui/providers": "17.6.0",
+    "@object-ui/react": "17.6.0",
+    "@object-ui/types": "17.6.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",

package/dist/widgets/CharacterCount.d.ts

@@ -1,56 +0,0 @@
-import { default as React } from 'react';
-export interface CharacterCountProps {
-    /**
-     * Length of the text this surface is counting. The inline surface passes the
-     * committed value's length; the fullscreen dialog passes the DRAFT's, which
-     * is the number that is true of what the user is looking at.
-     */
-    length: number;
-    /**
-     * The declared cap. Callers render this component only when the field
-     * declares one, so it is non-optional here — a counter with no cap to count
-     * against has nothing to say and must not be mounted at all (an unconditional
-     * live region in every long-text field is the objectui#3408 defect back
-     * again).
-     */
-    maxLength: number;
-    /**
-     * The description node's `id`, minted by the host from `useId()`.
-     *
-     * The host MUST also name it in the edited control's `aria-describedby` —
-     * this component renders the sentence, only the host knows which element is
-     * being described, and a description nothing references is a node no screen
-     * reader will ever reach. That association is asserted from the OUTSIDE (the
-     * tests resolve `aria-describedby` and concatenate the referenced nodes' text,
-     * exactly as an assistive technology does) rather than trusted here.
-     *
-     * Two surfaces of one widget therefore need two ids: the dialog's draft and
-     * the inline value diverge the moment the user types in the dialog, so one
-     * shared id would point both controls at whichever sentence rendered last.
-     */
-    descriptionId: string;
-    /**
-     * Render node 3, the threshold-gated debounced `aria-live` status region.
-     *
-     * Required on purpose — see the component doc above. `false` removes the
-     * region from the DOM entirely (not merely empties it), which is the only
-     * form of "no live region" a test can tell apart from "a live region that
-     * happens to be silent right now".
-     */
-    announceNearLimit: boolean;
-    /**
-     * Classes for the visible digits. Required because placement is entirely the
-     * surface's business — inline pins them to the textarea's bottom-right
-     * corner, the dialog lays them out as a footer item — and a default borrowed
-     * from either one would position the other wrongly while looking deliberate.
-     */
-    className: string;
-    /**
-     * `data-testid` for the visible digits, namespaced per surface
-     * (`textarea-character-count`, `textarea-fullscreen-character-count`) so a
-     * test that finds digits can say WHICH surface it found them on. Same
-     * convention, same reason, as `FullscreenFieldEditor`'s `testIdPrefix`.
-     */
-    testId: string;
-}
-export declare function CharacterCount({ length, maxLength, descriptionId, announceNearLimit, className, testId, }: CharacterCountProps): React.JSX.Element;