@object-ui/fields 17.2.0 → 17.3.0

package/dist/widgets/AddressField.d.ts

@@ -14,4 +14,4 @@ export interface AddressValue {
  * Address field widget - provides a structured address input
  * Supports street, city, state, zip code, and country
  */
-export declare function AddressField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<AddressValue>): React.JSX.Element;
+export declare function AddressField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<AddressValue>): React.JSX.Element;

package/dist/widgets/AvatarField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * Avatar field widget - provides an avatar/profile picture uploader
  * Supports image URLs or file uploads
  */
-export declare function AvatarField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function AvatarField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/CharacterCount.d.ts

@@ -0,0 +1,56 @@
+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;

package/dist/widgets/CheckboxesField.d.ts

@@ -12,4 +12,4 @@ import { FieldWidgetComponentProps } from './types';
  * first" hint while a dependency is empty, and selections no longer offered
  * (parent changed / predicate flipped) are pruned from the array.
  */
-export declare function CheckboxesField({ value, onChange, field, readonly, className, schema, dependentValues, dependsOn: dependsOnProp, emptyHint: _emptyHint, dataSource: _dataSource, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;
+export declare function CheckboxesField({ value, onChange, field, readonly, className, dependentValues, dependsOn: dependsOnProp, emptyHint, dataSource: _dataSource, error, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;

package/dist/widgets/CodeField.d.ts

@@ -5,4 +5,4 @@ import { FieldWidgetComponentProps } from './types';
  * Uses a simple textarea with monospace font
  * For advanced code editing, use the @object-ui/plugin-editor component
  */
-export declare function CodeField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function CodeField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/ColorField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * Color field widget - provides a color picker input
  * Supports hex color values (e.g., #ff0000)
  */
-export declare function ColorField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function ColorField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/CurrencyField.d.ts

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
 import { FieldWidgetComponentProps } from './types';
-export declare function CurrencyField({ value, onChange, field, readonly, errorMessage, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;
+export declare function CurrencyField({ value, onChange, field, readonly, error, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;

package/dist/widgets/EmailField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * EmailField - Email address input with mailto link in readonly mode
  * Renders as a clickable mailto link when readonly, standard email input otherwise
  */
-export declare function EmailField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function EmailField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/FileField.d.ts

@@ -5,7 +5,7 @@ import { FieldWidgetComponentProps } from './types';
  * Supports single and multiple file uploads with configurable accepted file types.
  * L2: File size validation, per-file progress indicators, error messages.
  */
-export declare function FileField({ value, onChange, field, readonly, onUploadingChange, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function FileField({ value, onChange, field, readonly, onUploadingChange, error, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
 /**
  * FileCell — compact upload control for a line-item grid cell (objectui#2360).
  *

package/dist/widgets/FilterConditionField.d.ts

@@ -32,5 +32,5 @@ export declare function kvToCondition(field: string, v: any, idx: number): Build
  * @internal exported for tests
  */
 export declare function isMatchAllCriteria(parsed: any): boolean;
-export declare function FilterConditionField({ value, onChange, readonly, className, ...props }: FieldWidgetComponentProps<string | object>): React.JSX.Element;
+export declare function FilterConditionField({ value, onChange, readonly, className, error, ...props }: FieldWidgetComponentProps<string | object>): React.JSX.Element;
 export default FilterConditionField;

package/dist/widgets/FullscreenFieldEditor.d.ts

@@ -0,0 +1,155 @@
+import { default as React } from 'react';
+/**
+ * The fullscreen-edit affordance shared by every long-text widget: the "expand"
+ * button plus the full-height dialog it opens.
+ *
+ * ## Why this is shared rather than copied
+ *
+ * `ObjectFormSchema.mobile.fullscreenLongText` is ONE form-level promise, and
+ * `ObjectForm` projects it onto EVERY long-text field as `mobile_fullscreen`
+ * (`field:textarea` → `TextAreaField`, `field:markdown` / `field:html` →
+ * `RichTextField`). A user who turns the setting on gets one behaviour, so the
+ * behaviour has one implementation. objectui#3301 is what the other
+ * arrangement costs: the flag reached `RichTextField` for as long as the
+ * feature has existed and that widget simply never read it, so half the
+ * documented promise ("textarea/rich-text get an expand button") silently did
+ * nothing. A second hand-written copy of the state machine is the same failure
+ * with an extra step — it drifts, and nothing reports the drift.
+ *
+ * What is genuinely per-widget is the EDITOR, so that is the only thing
+ * injected: `children` renders it against the draft. Everything a user can
+ * observe about the *interaction* — when the affordance appears, that the
+ * dialog seeds from the committed value, that typing stays local until "Done",
+ * that "Cancel" discards — lives here, once.
+ *
+ * ## Draft semantics (unchanged from the original `TextAreaField` behaviour)
+ *
+ * The dialog edits a LOCAL draft seeded from `value` at open time and commits
+ * once, on "Done". It deliberately does not stream every keystroke to the host:
+ * these widgets sit in a react-hook-form field, and per-keystroke `onChange`
+ * during a modal edit would mark the form dirty (and fire validation) for an
+ * edit the user may still cancel. "Cancel" therefore needs no undo — nothing
+ * was written.
+ *
+ * ## `disabled` (objectui#3402)
+ *
+ * The dialog is a SECOND editing surface for the same value, so a field that is
+ * not interactive has to be not interactive here too. It was not: hosts landed
+ * `disabled` on their inline control only, this component never declared the
+ * prop at all, and a disabled long-text field therefore sat correctly greyed out
+ * next to a live expand button — click it, type anything, press "Done", and the
+ * edit went into form state through `onCommit`. Measured on `origin/main`
+ * before the fix: inline `disabled=true`, toggle `disabled=false`, dialog input
+ * `disabled=false`, `onChange` called with "EDITED WHILE DISABLED".
+ *
+ * The gate is shaped like the built-in path's (`FullscreenTextarea` in
+ * `components/src/renderers/form/form.tsx`, objectui#3400/PR #3401), because
+ * one form-level setting must keep producing one behaviour on both paths:
+ *
+ *  - the toggle STAYS but is `disabled` — `disabled` means "not interactive,
+ *    muted", not "shown plainly", which is `readonly`'s job (and `readonly`
+ *    never reaches this component at all — see below);
+ *  - `openFullscreen` refuses independently of the attribute, since a
+ *    programmatic dispatch and a lost `pointer-events` rule both get past it;
+ *  - the dialog locks on its OWN — `disabled` is not merely a static flag, it is
+ *    also the form's `isSubmitting`, which flips to true while the dialog may
+ *    already be open. At that moment the toggle is no longer the gate. So the
+ *    editor is told (third `children` argument) and "Done" is disabled;
+ *  - and `onCommit` is gated, because that is the single point where a value can
+ *    leave this component for host state. Nothing native guards it: it is a
+ *    click handler on a different control reading React state.
+ *
+ * "Cancel" and `Esc` stay live in every state — a dialog that goes disabled
+ * mid-edit must still be closable, or a submit in flight traps the user in it.
+ *
+ * ## Why there is no `readonly` prop
+ *
+ * Both hosts early-return a read-only DISPLAY before they compute the affordance
+ * (`TextAreaField.tsx`, `RichTextField.tsx`), so this component is never
+ * rendered for a read-only field and a `readonly` prop here would be declared
+ * with no producer — the shape this package keeps deleting (objectui#3232/#3233).
+ * A future host that renders an editor for read-only fields must add the prop
+ * AND the producer together; do not add it "for symmetry" beforehand.
+ *
+ * ## `testIdPrefix`
+ *
+ * Each host passes its own (`textarea`, `richtext`), yielding the same
+ * convention with a per-widget namespace: `<prefix>-fullscreen-toggle` /
+ * `-dialog` / `-save`. One form can contain both a textarea and a markdown
+ * field, so a single shared id would make a test unable to say which widget it
+ * had found. The editor's own test id belongs to `children` for the same
+ * reason.
+ *
+ * ## Copy (objectui#3404)
+ *
+ * Every string here goes through `useFieldTranslation()` and consumes the
+ * EXISTING `form.fullscreen.*` / `common.cancel` keys — the same ones the
+ * built-in branch consumes since objectui#3272. Nothing was missing from the
+ * ten locale packs; this path simply never read them, so a zh session opened a
+ * dialog reading `Cancel` / `Done` while a long-text field rendered by the
+ * built-in branch **in the same form** read 「取消 / 完成」.
+ *
+ * Sharing the keys rather than minting `fields.fullscreen.*` twins is the
+ * point: one form-level setting (`mobile.fullscreenLongText`) projects onto
+ * both render paths, so two copies of this copy could only drift.
+ *
+ * `useFieldTranslation` (not bare `useObjectTranslation`) because this widget
+ * is rendered without an `I18nProvider` by standalone/embedded hosts and by
+ * every bare-render test in this package. Measured before the change: with no
+ * provider mounted `useObjectTranslation().t('common.cancel')` returns
+ * `"common.cancel"` — the raw key — and the `{{label}}` interpolation collapses
+ * entirely. The safe hook's English defaults are byte-identical to the literals
+ * they replaced, so the provider-less rendering is unchanged.
+ *
+ * Focus management, `Esc`, the overlay and the close button are Radix's, via
+ * the repo's `Dialog` (`@object-ui/components`) — deliberately not re-answered
+ * here.
+ */
+export interface FullscreenFieldEditorProps {
+    /**
+     * The committed value. Seeds the draft each time the dialog opens — read at
+     * open time, not held, so a value that changes underneath while the dialog is
+     * closed is picked up on the next open.
+     */
+    value: string;
+    /** Called once with the draft when the user confirms. */
+    onCommit: (next: string) => void;
+    /** Field label — the dialog title and part of the toggle's accessible name. */
+    label?: string;
+    /** Namespace for this widget's fullscreen test ids. See above. */
+    testIdPrefix: string;
+    /**
+     * The host field is not interactive (objectui#3402). Disables the toggle, the
+     * "Done" button and the write-back, and is handed to `children` so the host's
+     * own editor renders disabled too. See the `disabled` section above for why
+     * each of those is a separate line rather than belt-and-braces.
+     *
+     * **Producer**: the widget's `disabled` prop, which the form renderer computes
+     * as `disabled || fieldDisabled || isSubmitting || optionGroupGated` and
+     * forwards to registered widgets (`stripRegisteredFieldProps` does not strip
+     * it).
+     */
+    disabled?: boolean;
+    /**
+     * The editor itself, rendered inside the dialog body against the draft. The
+     * host passes the SAME editor it renders inline, so "fullscreen" is a size
+     * change rather than a second, poorer editing surface.
+     *
+     * The third argument is this component's `disabled`, and the host is expected
+     * to put it on the control it renders: only the host knows which element its
+     * editor's disabled state belongs on. Ignoring it is not a write-back hole —
+     * `onCommit` is gated here regardless — but it does leave a control that looks
+     * editable while the field is not, so both in-repo hosts apply it and their
+     * tests pin it.
+     */
+    children: (draft: string, setDraft: (next: string) => void, disabled: boolean) => React.ReactNode;
+    /** Optional footer status for the draft (e.g. a character counter). */
+    footer?: (draft: string) => React.ReactNode;
+    /**
+     * Extra classes for the toggle button. It is absolutely positioned by
+     * default and expects a `relative` ancestor; a host whose layout has a
+     * better home for it can re-place it here.
+     */
+    toggleClassName?: string;
+}
+export declare function FullscreenFieldEditor({ value, onCommit, label, testIdPrefix, disabled, children, footer, toggleClassName, }: FullscreenFieldEditorProps): React.JSX.Element;

package/dist/widgets/GeolocationField.d.ts

@@ -12,4 +12,4 @@ export interface GeolocationValue {
  * Geolocation field widget - provides a location picker with coordinates
  * Supports manual entry and browser geolocation API
  */
-export declare function GeolocationField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<GeolocationValue>): React.JSX.Element;
+export declare function GeolocationField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<GeolocationValue>): React.JSX.Element;

package/dist/widgets/ImageField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * ImageField - Image upload widget with preview thumbnails
  * Supports single and multiple image uploads with drag-and-drop and preview display
  */
-export declare function ImageField({ value, onChange, field, readonly, onUploadingChange, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function ImageField({ value, onChange, field, readonly, onUploadingChange, error, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/LocationField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * LocationField - Geographic coordinate input for latitude and longitude
  * Stores location as { latitude, longitude } object and displays as comma-separated pair
  */
-export declare function LocationField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function LocationField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/LookupField.d.ts

@@ -15,4 +15,4 @@ export interface LookupOption {
  * from the referenced object using `DataSource.find()`.
  * Falls back to static `options` when no DataSource is available.
  */
-export declare function LookupField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function LookupField({ value, onChange, field, readonly, error: fieldError, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/LookupField.gateHintLabel.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};

package/dist/widgets/MultiSelectField.d.ts

@@ -14,4 +14,4 @@ import { FieldWidgetComponentProps } from './types';
  * parent first" hint while a dependency is empty, and selections no longer
  * offered (parent changed / predicate flipped) are dropped from the array.
  */
-export declare function MultiSelectField({ value, onChange, field, readonly, className, schema, dependentValues, dependsOn: dependsOnProp, emptyHint: _emptyHint, dataSource: _dataSource, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;
+export declare function MultiSelectField({ value, onChange, field, readonly, className, dependentValues, dependsOn: dependsOnProp, emptyHint, dataSource: _dataSource, error, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;

package/dist/widgets/ObjectField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * ObjectField - JSON object editor
  * Allows editing structured JSON data
  */
-export declare function ObjectField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;
+export declare function ObjectField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<any>): React.JSX.Element;

package/dist/widgets/ObjectRefField.d.ts

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 import { FieldWidgetComponentProps } from './types';
-export declare function ObjectRefField({ value, onChange, readonly, className, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function ObjectRefField({ value, onChange, readonly, className, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
 export default ObjectRefField;

package/dist/widgets/OptionsEmptyState.d.ts

@@ -0,0 +1,45 @@
+import { default as React } from 'react';
+/**
+ * The "this option list cannot be filled" state shared by every fixed-option
+ * widget (`SelectField` single, `MultiSelectField`, `RadioField`,
+ * `CheckboxesField`) — objectui#3231.
+ *
+ * ## One producer, one consumer
+ *
+ * `emptyHint` is a declared prop on `FieldWidgetComponentProps`, computed by
+ * the form renderer (`form.tsx`, the `#2284` dependency gate) and forwarded to
+ * these widgets. **When the host supplies it, it wins**: the host resolves the
+ * controlling fields to their human LABELS ("Select Country first"), where a
+ * widget on its own only knows the raw metadata names ("Select country first").
+ * Absent a host hint — a standalone widget, the inline grid editor, an action
+ * param dialog — the widget falls back to its own copy.
+ *
+ * Each of the four widgets used to inline this box, destructure `emptyHint`
+ * into `_emptyHint` and throw it away, then render a hardcoded English literal.
+ * Four independent copies is precisely why they drifted together, so the box
+ * AND the copy live here only: adding a fifth option widget cannot re-introduce
+ * the gap without deliberately re-implementing it.
+ *
+ * ## Fallback copy is translated
+ *
+ * The fallback goes through `useFieldTranslation()` (`fields.options.*`,
+ * present in all ten locale packs) rather than an English string literal — the
+ * gate sentence is the SAME i18n key the form renderer uses, so the two can
+ * never say different things in the same locale.
+ */
+export interface OptionsEmptyStateProps {
+    /**
+     * Host-computed hint. Wins over the widget's own copy whenever it is a
+     * non-empty string — this is the whole point of the prop.
+     */
+    emptyHint?: string;
+    /** The list is waiting on a `dependsOn` controlling field (vs. unconfigured). */
+    gated: boolean;
+    /** Controlling field names, used by the fallback gate sentence. */
+    dependsOnFields: readonly string[];
+    /** Widget-specific stable locator, e.g. `select-empty-${fieldName}`. */
+    testId?: string;
+    /** Widget-specific sizing (the dropdown is a fixed `h-9`, lists grow). */
+    className?: string;
+}
+export declare function OptionsEmptyState({ emptyHint, gated, dependsOnFields, testId, className, }: OptionsEmptyStateProps): React.JSX.Element;

package/dist/widgets/PercentField.d.ts

@@ -5,4 +5,4 @@ import { FieldWidgetComponentProps } from './types';
  * Stores values as decimals (0-1) and displays as percentages (0-100%)
  * Includes a slider for interactive control.
  */
-export declare function PercentField({ value, onChange, field, readonly, errorMessage, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;
+export declare function PercentField({ value, onChange, field, readonly, error, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;

package/dist/widgets/PhoneField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * PhoneField - Telephone number input with tel link in readonly mode
  * Renders as a clickable tel link when readonly, standard phone input otherwise
  */
-export declare function PhoneField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function PhoneField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/QRCodeField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * QR Code field widget - generates QR codes from text
  * Uses a simple SVG-based QR code generator
  */
-export declare function QRCodeField({ value, onChange, field, readonly, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function QRCodeField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/RadioField.d.ts

@@ -12,4 +12,4 @@ import { FieldWidgetComponentProps } from './types';
  * first" hint while a dependency is empty, and a value no longer offered (parent
  * changed / predicate flipped) is cleared.
  */
-export declare function RadioField({ value, onChange, field, readonly, className, schema, dependentValues, dependsOn: dependsOnProp, emptyHint: _emptyHint, dataSource: _dataSource, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function RadioField({ value, onChange, field, readonly, className, dependentValues, dependsOn: dependsOnProp, emptyHint, dataSource: _dataSource, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/RatingField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * Rating field widget - provides a star rating input
  * Supports numeric values from 0 to max (default 5)
  */
-export declare function RatingField({ value, onChange, field, readonly, className, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;
+export declare function RatingField({ value, onChange, field, readonly, className, error, ...props }: FieldWidgetComponentProps<number>): React.JSX.Element;

package/dist/widgets/RecipientPickerField.d.ts

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 import { FieldWidgetComponentProps } from './types';
-export declare function RecipientPickerField({ value, onChange, readonly, className, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function RecipientPickerField({ value, onChange, readonly, className, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
 export default RecipientPickerField;

package/dist/widgets/RecordPickerDialog.d.ts

@@ -140,6 +140,22 @@ export interface RecordPickerDialogProps {
      * Typically pass `getCellRenderer` from @object-ui/fields.
      */
     cellRenderer?: CellRendererResolver;
+    /**
+     * The referenced object's schema `fields` map (field name → field
+     * definition). When provided, cell renderers receive the FULL field
+     * metadata — `options`, `currency`, `scale`, `precision`, `format`,
+     * `reference_to`, … — exactly like the list view enriches its columns from
+     * the object schema. Without it a `select` column falls back to
+     * title-casing the raw stored value instead of resolving the option label
+     * (#3333: `manufacturing` rendered as "Manufacturing" instead of the
+     * authored option label).
+     *
+     * The filter bar reads the same map: a `select` filter column with no
+     * authored `options` takes them from the schema field here, so the filter
+     * panel's dropdown offers exactly the options the table cells render
+     * (#3336 — it used to open empty, leaving the field unfilterable).
+     */
+    fieldsMeta?: Record<string, any>;
     /**
      * Filter bar column definitions.
      * When provided, shows an inline filter bar below the search input.
@@ -185,4 +201,4 @@ export interface RecordPickerDialogProps {
  * states, and single/multi-select.  Responsive: mobile-friendly width
  * via Tailwind breakpoints.
  */
-export declare function RecordPickerDialog({ open, onOpenChange, title, multiple, dataSource, objectName, columns: columnsProp, displayField, titleFormat, idField, pageSize, value, onSelect, onSelectRecords, lookupFilters, baseFilter, cellRenderer, filterColumns, renderFilterBar, renderGrid, }: RecordPickerDialogProps): React.JSX.Element;
+export declare function RecordPickerDialog({ open, onOpenChange, title, multiple, dataSource, objectName, columns: columnsProp, displayField, titleFormat, idField, pageSize, value, onSelect, onSelectRecords, lookupFilters, baseFilter, cellRenderer, fieldsMeta, filterColumns, renderFilterBar, renderGrid, }: RecordPickerDialogProps): React.JSX.Element;

package/dist/widgets/RecordPickerDialog.filterOptions.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};

package/dist/widgets/RecordPickerDialog.selectLabel.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};

package/dist/widgets/RichTextField.d.ts

@@ -4,5 +4,23 @@ import { FieldWidgetComponentProps } from './types';
  * Rich text field with markdown/HTML support
  * For now, this is a simple textarea. A full implementation would use
  * a rich text editor like TipTap, Lexical, or Slate.
+ *
+ * Reached by forms as `field:markdown` and `field:html`; both resolve here.
+ *
+ * ## Fullscreen editing (objectui#3301)
+ *
+ * `ObjectForm` stamps `mobile_fullscreen` onto the metadata of every long-text
+ * field — textarea AND rich-text — when `ObjectFormSchema.mobile
+ * .fullscreenLongText` is set, and `ObjectFormSchema.mobile`'s own JSDoc has
+ * always promised "textarea/rich-text get an expand button". This widget never
+ * read the flag, so for `field:markdown` / `field:html` that promise did
+ * nothing at all: the producer stamped, and no consumer existed.
+ *
+ * The flag is read off `field` and nowhere else — the single metadata carrier
+ * since objectui#3233 — matching `TextAreaField` read for read, so a
+ * misspelled flag stays inert in both widgets rather than being caught by a
+ * tolerant fallback in one of them. The affordance and dialog themselves come
+ * from the shared `FullscreenFieldEditor`, so one form-level setting keeps
+ * producing one behaviour across both widgets.
  */
-export declare function RichTextField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function RichTextField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/TagsField.d.ts

@@ -5,4 +5,4 @@ import { FieldWidgetComponentProps } from './types';
  * comma) to add it; click a tag's × to remove it. The stored value is a
  * string[]. Used for the `tags` field type.
  */
-export declare function TagsField({ value, onChange, field, readonly, className, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;
+export declare function TagsField({ value, onChange, field, readonly, className, error, ...props }: FieldWidgetComponentProps<string[]>): React.JSX.Element;

package/dist/widgets/TextAreaField.d.ts

@@ -4,9 +4,48 @@ import { FieldWidgetComponentProps } from './types';
  * TextAreaField - Multi-line text input widget
  * Supports configurable row count and preserves whitespace in readonly mode.
  *
- * Mobile UX (round 3): when the host form passes `mobileFullscreen` (or the
- * field schema sets `mobile_fullscreen: true`), an "expand" affordance opens
- * a fullscreen edit dialog — much easier on phones than tapping a 4-row
- * textarea trapped between other fields.
+ * Mobile UX (round 3): when the FIELD METADATA carries `mobile_fullscreen:
+ * true`, an "expand" affordance opens a fullscreen edit dialog — much easier
+ * on phones than tapping a 4-row textarea trapped between other fields.
+ *
+ * That flag has exactly one producer: `ObjectForm` stamps it onto every
+ * long-text field when `ObjectFormSchema.mobile.fullscreenLongText` is set
+ * (`plugin-form/src/ObjectForm.tsx`). It reaches this widget on `field` — the
+ * single metadata carrier since objectui#3233. A `SchemaRenderer`-hosted node
+ * arrives there too: the registry adapter (`withFieldCarrier`) maps the SDUI
+ * `schema` node onto `field` before the widget sees it.
+ *
+ * The affordance, the dialog and the draft/commit semantics live in the shared
+ * `FullscreenFieldEditor` — the same producer stamps the same flag on
+ * rich-text fields, and `RichTextField` renders it from there too
+ * (objectui#3301). Only the EDITOR differs per widget; here it is a
+ * full-height `Textarea`.
+ *
+ * There is deliberately NO widget-prop override. A `mobileFullscreen`
+ * (camelCase) prop was read here and written by nobody in the repo, and the
+ * snake_case `mobile_fullscreen` prop cannot arrive either: the form renderer
+ * strips both `mobile_fullscreen` and `fullscreen` from the props it forwards
+ * to registered widgets (`stripRegisteredFieldProps` in
+ * `components/src/renderers/form/form.tsx`). Reading keys nobody produces
+ * documented a contract that never held and invited the next author to pass a
+ * silently-ignored prop, so the reads are gone (objectui#3232). If a host
+ * override is ever genuinely needed, declare ONE key on
+ * `FieldWidgetComponentProps`, stop stripping it, and have a host pass it.
+ *
+ * ## 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
+ * 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
+ * is what a second copy of a UI always costs: it drifts, and nothing reports
+ * the drift.
+ *
+ * This widget's remaining job is the part only it can do — mint the two
+ * description ids and name each one in the `aria-describedby` of the control
+ * it describes. The surfaces differ in exactly one behaviour, and it is
+ * declared rather than implied: `announceNearLimit`. Inline announces
+ * (unchanged since #3408); the fullscreen dialog does not.
  */
-export declare function TextAreaField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function TextAreaField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;

package/dist/widgets/UrlField.d.ts

@@ -4,4 +4,4 @@ import { FieldWidgetComponentProps } from './types';
  * UrlField - URL input with clickable link in readonly mode
  * Validates URLs to only render http/https links for security
  */
-export declare function UrlField({ value, onChange, field, readonly, errorMessage, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;
+export declare function UrlField({ value, onChange, field, readonly, error, ...props }: FieldWidgetComponentProps<string>): React.JSX.Element;