@dcs-tech/ui 0.2.0 → 0.3.0

package/dist/types/shared-types/src/ui/control.types.d.ts

@@ -1,131 +1,34 @@
 import type { ReactNode } from 'react';
-/**
- * The one vocabulary every control in @pdfinvoice/shared-web-ui speaks.
- *
- * Before this file each component re-spelled its own `Size`, `Layout` and
- * `Color` unions by hand. They agreed today by coincidence, not by
- * construction — `ButtonSize` and `FieldSize` listed the same six literals in
- * two places, and `ChipInputLayout` said `vertical` for the thing every other
- * control called `default`. Anything declared here is declared once; the
- * per-component names remain, as aliases, so call sites and the published
- * barrel are unaffected.
- *
- * Adding a step or a colour here widens every control at once — which is the
- * point, and also the hazard: a literal with no CSS behind it ships a variant
- * that renders as nothing. Widen the stylesheet in the same stroke.
- */
-/**
- * The size scale. Every control resolves to this, so `size="small"` means the
- * same height, padding and font on an Input, a Checkbox and a Button standing
- * next to each other.
- *
- * Each step maps to `--field-height-*`, `--field-padding-x/y-*`,
- * `--control-size-*` and `--font-size-*` in @pdfinvoice/shared-styles.
- */
 export type ControlSize = 'xxs' | 'xs' | 'small' | 'medium' | 'large' | 'xl';
-/**
- * The default every control falls back to when neither a `size` prop nor an
- * enclosing FieldContext supplies one.
- *
- * It is `small` because this is a dense ERP: the invoice grid is the busiest
- * screen in the product and sets the house density. Previously the fields
- * defaulted to `small` and the toggles to `medium`, so a Checkbox beside an
- * Input was a step larger with no props passed on either.
- */
 export declare const DEFAULT_CONTROL_SIZE: ControlSize;
-/**
- * Surface treatment for controls that render a text-entry surface — Input,
- * Select, Suggest, ChipInput. They share one border/background/radius/focus
- * definition, so an outlined Select is the same surface as the outlined Input
- * beside it.
- *
- * `underlined` only makes sense here: it draws a rule beneath the text line.
- */
 export type ControlVariant = 'outlined' | 'filled' | 'standard' | 'underlined' | 'cell';
-/**
- * Surface treatment for the box-shaped toggles — Checkbox and Radio.
- *
- * Deliberately NOT ControlVariant: a checkbox has no text line to underline, so
- * `underlined` would be a valid type with no styling behind it and the control
- * would render with no border or fill. Switch has no variant at all — it has a
- * single track/thumb look by design.
- */
 export type ToggleVariant = 'outlined' | 'filled' | 'standard' | 'cell';
-/** How a control arranges its label against its control box. */
 export type ControlLayout = 'default' | 'horizontal' | 'inline' | 'cell';
-/** Where a toggle's own label sits relative to its box. */
 export type ControlLabelPosition = 'start' | 'end' | 'top' | 'bottom';
-/**
- * The palette's semantic axis. Each member has its own hue variable in
- * `tokens.css` and its own `--on-*` contrast text.
- *
- * Components take a subset via `Extract`/`Exclude` rather than re-listing:
- * `neutral` is a button/surface idea, not a state a field can be in.
- */
 export type SemanticColor = 'primary' | 'secondary' | 'success' | 'error' | 'warning' | 'info' | 'neutral';
-/** What a form control can be tinted: every semantic except the neutral surface. */
 export type FieldColor = Exclude<SemanticColor, 'neutral'>;
-/**
- * The minimum a change event carries.
- *
- * A native `ChangeEvent<HTMLInputElement>` satisfies this structurally, which
- * is the whole trick: Input, Checkbox, Radio, Switch and Suggest keep emitting
- * real DOM events (so `currentTarget` and `preventDefault` survive), while
- * Select and ChipInput — which have no DOM event to forward — emit this shape.
- * A single handler typed `(e: FieldChangeEvent) => void` therefore accepts a
- * change from any field, which is what Fields, EditableTable and the keyboard
- * grid need in order to write one handler per row instead of one per widget.
- *
- * Keep this narrow. Every property added here is one more thing the synthetic
- * emitters have to fabricate.
- */
 export interface FieldChangeTarget<V = any> {
     name?: string;
     value: V;
-    /** Mirrors the DOM `type` so `createChangeHandler` can branch on it. */
     type?: string;
-    /** Only meaningful for checkbox/radio inputs. */
     checked?: boolean;
 }
 export interface FieldChangeEvent<V = any> {
     target: FieldChangeTarget<V>;
 }
-/**
- * What a container (Form, Fields, an editable-table row) hands down to the
- * fields inside it. Every member optional and unset by default — a field has to
- * be able to tell "nobody said" from "someone said small".
- */
 export interface FieldContextValue {
     size?: ControlSize;
     variant?: ControlVariant;
     layout?: ControlLayout;
     disabled?: boolean;
     readOnly?: boolean;
-    /**
-     * The keyboard policy for everything beneath. This is how a grid says
-     * "every cell in here is in grid mode" and a form says "Enter moves to the
-     * next field" — once, rather than on every field.
-     *
-     * @see FieldKeyboardConfig in `keyboard.types`. Typed structurally here to
-     * keep `control.types` a leaf that imports nothing.
-     */
     keyboard?: import('./keyboard.types').FieldKeyboardConfig;
 }
 export interface FieldProviderProps extends FieldContextValue {
     children?: ReactNode;
 }
-/**
- * What an editable-table cell needs to tell the widget sitting in it.
- *
- * These five used to be five separate public props on Input, Select and Suggest
- * — with Suggest re-declaring them inline and typing `registerCellRef` against
- * `HTMLInputElement` where Input typed `HTMLElement`. Grouping them keeps the
- * grid's plumbing out of the props panel and gives the two implementations one
- * signature to agree on.
- */
 export interface FieldCellContext {
     rowIndex?: number;
-    /** Lower-case to match the `data-cellindex` attribute the DOM carries. */
     cellindex?: number;
     onCellFocus?: (rowIndex: number, cellindex: number) => void;
     registerCellRef?: (rowIndex: number, cellindex: number, ref: HTMLElement | null) => void;

package/dist/types/shared-types/src/ui/datePicker.types.d.ts

@@ -0,0 +1,46 @@
+import type { ReactNode } from 'react';
+import type { FieldChangeEvent } from './control.types';
+import type { FieldPopupProps, TextFieldProps } from './field.types';
+export type DateDisplayFormat = 'dd-mm-yyyy' | 'dd/mm/yyyy' | 'yyyy-mm-dd';
+export type DateTextOrder = 'dmy' | 'mdy' | 'ymd';
+export interface DateRangeValue {
+    from: string;
+    to: string;
+}
+export interface DatePickerBaseProps extends Omit<TextFieldProps<string, HTMLInputElement, FieldChangeEvent<string>>, 'value' | 'onChange'>, FieldPopupProps {
+    withTime?: boolean;
+    min?: string;
+    max?: string;
+    displayFormat?: DateDisplayFormat;
+    textOrder?: DateTextOrder;
+    weekStart?: number;
+    months?: number;
+    currentMonthSide?: 'left' | 'right';
+    showOutsideDays?: boolean;
+    presets?: boolean | string[];
+    fyStartMonth?: number;
+    monthNames?: string[];
+    weekdayNames?: string[];
+    clearLabel?: string;
+    applyLabel?: string;
+    timeToggle?: boolean;
+    placement?: 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+    showCalendarIcon?: boolean;
+    clearable?: boolean;
+    placeholder?: string;
+    hint?: ReactNode;
+    error?: ReactNode;
+}
+export interface DatePickerSingleProps extends DatePickerBaseProps {
+    range?: false;
+    value?: string;
+    onChange?: (event: FieldChangeEvent<string>) => void;
+    onApply?: (value: string) => void;
+}
+export interface DatePickerRangeProps extends DatePickerBaseProps {
+    range: true;
+    value?: DateRangeValue;
+    onChange?: (event: FieldChangeEvent<DateRangeValue>) => void;
+    onApply?: (value: DateRangeValue) => void;
+}
+export type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps;

package/dist/types/shared-types/src/ui/editableTable.types.d.ts

@@ -2,15 +2,7 @@ import type { ReactNode, CSSProperties, ChangeEvent, KeyboardEvent } from 'react
 import type { FieldKeyboardConfig } from './keyboard.types';
 import type { TableColumnDisplayProps, TableSummaryConfig, SummaryLicenseConfig } from './table.types';
 import type { CheckboxFieldDefinition, InputFieldDefinition, SwitchFieldDefinition, SelectFieldDefinition, SuggestFieldDefinition, RadioFieldDefinition, ButtonFieldDefinition, ChildFieldDefinition } from './fields.types';
-/**
- * A column: a field definition (what edits the value) plus the Table's display
- * props (how the cell is laid out and what it shows when read-only).
- *
- * Intersected rather than added to `BaseFieldDefinition` so an ordinary form
- * field never grows a meaningless `width` or `sticky`.
- */
 export type EditableTableColumnDefinition<T = any> = (InputFieldDefinition<T> | SwitchFieldDefinition<T> | SelectFieldDefinition<T> | SuggestFieldDefinition<T> | RadioFieldDefinition<T> | CheckboxFieldDefinition<T> | ButtonFieldDefinition<T> | ChildFieldDefinition<T>) & TableColumnDisplayProps<T>;
-/** Row operations a summary can drive — so a screen can put "Add from stock" beside its totals. */
 export interface EditableTableSummaryActions {
     addRow: () => void;
     copyRow: () => void;
@@ -19,7 +11,6 @@ export interface EditableTableSummaryActions {
 }
 export interface EditableTableSummaryContext<T = any> {
     rows: T[];
-    /** Resolved column totals, keyed by column `name`. */
     totals: Record<string, number | string>;
     focusedRowIndex: number | null;
     actions: EditableTableSummaryActions;
@@ -46,24 +37,12 @@ export interface EditableTableAddConfig {
         rowData: any;
         tableData: any[];
     }) => Record<string, any>;
-    /**
-     * The consumer's own veto on creating a row. Runs after the built-in policy below.
-     * (Was declared but never called before 2026-09-17 — it is wired now.)
-     */
     canAdd?: (context: {
         rowIndex: number;
         rowData: any;
         tableData: any[];
     }) => boolean;
-    /**
-     * Allow a new row while a BLANK one is already there. Default `false`: holding Enter at
-     * the end of a table used to append an empty row per press, so an invoice ended with a
-     * tail of blanks. With the default, the blank row must be filled before the next appears.
-     */
     allowWhenBlankRow?: boolean;
-    /**
-     * Allow a new row while some row still fails a `'block'` rule. Default `false`.
-     */
     allowWhenInvalid?: boolean;
 }
 export interface EditableTableDeleteConfig {
@@ -74,51 +53,31 @@ export interface EditableTableDeleteConfig {
         tableData: any[];
     }) => boolean;
 }
-/** One cell that failed, with the message the cell is showing. */
 export interface EditableTableRowFailure {
     cellindex: number;
-    /** The column's `name`, so a caller can report "Qty" without knowing column order. */
     column: string;
     message: string;
     severity: 'block' | 'warn';
 }
 export interface EditableTableRowValidity {
     rowIndex: number;
-    /** No failures at all — warnings included. */
     valid: boolean;
-    /** At least one `'block'` failure: this row is what refuses a new row, and your save. */
     blocked: boolean;
     failures: EditableTableRowFailure[];
 }
 export interface EditableTableValidity {
-    /** Every row passes, warnings included. */
     valid: boolean;
-    /** Nothing is BLOCKING — the answer a save button wants. */
     blocked: boolean;
-    /** Only the rows with something to report. An untouched row is never judged. */
     rows: EditableTableRowValidity[];
-    /** Where to send the operator first, or `null`. */
     firstBlocking: {
         rowIndex: number;
         cellindex: number;
         message: string;
     } | null;
 }
-/**
- * The table's imperative handle — the same shape of thing as `FormMethods`, obtained the
- * same way (a `ref`), because a table is the other half of the same entry screen.
- *
- * The validity answers are already computed for the red edges; this hands them out, so a
- * consumer's save asks "may I?" instead of re-implementing a single rule. For LIVE state —
- * a Save button that disables itself as someone types — use the `onValidityChange` prop: a
- * ref is imperative and re-renders nothing.
- */
 export interface EditableTableMethods<T = any> {
-    /** Resolve every row's rules now. Synchronous: the rules are pure. */
     validate: () => EditableTableValidity;
-    /** `true` when nothing blocks — the one-line form of `validate()`. */
     isValid: () => boolean;
-    /** Focus the first blocking cell; `false` when there is nothing to go to. */
     focusFirstInvalid: () => boolean;
     getRows: () => T[];
     getRowValidity: (rowIndex: number) => EditableTableRowValidity;
@@ -151,48 +110,18 @@ export interface EditableTableProps<T = any> {
     title?: string | ReactNode;
     footerConfig?: EditableTableFooterConfig;
     onFocusChange?: (focus: EditableTableFocusState) => void;
-    /**
-     * Fires when the table's validity changes — for live UI, such as a Save button that
-     * disables itself. The imperative `ref` answers the same question at save time.
-     */
     onValidityChange?: (validity: EditableTableValidity) => void;
-    /**
-     * Animate rows arriving and leaving, and flash the cell focus lands on afterwards.
-     * Default `true`. `prefers-reduced-motion` switches it off regardless — including the
-     * short delay a leaving row needs, so nobody gets a slower delete for no animation.
-     */
     animateRows?: boolean;
     copyConfig?: EditableTableCopyConfig;
     addConfig?: EditableTableAddConfig;
     deleteConfig?: EditableTableDeleteConfig;
-    /** Icons for action buttons — replaces direct react-icons imports */
     addIcon?: ReactNode;
     copyIcon?: ReactNode;
     deleteIcon?: ReactNode;
     additionalActions?: EditableTableAdditionalAction<T>[];
-    /**
-     * The area under the table — for everything that is not a column total.
-     *
-     * The config form is the client Table's `TableSummaryConfig`, unchanged, so a
-     * summary written for a report table works here as-is. The render form is the
-     * escape hatch: rows, resolved totals and the row actions, for custom figures
-     * or action buttons. Column totals themselves come from each column's
-     * `summable` / `summary` and render in the pinned footer row.
-     */
     summary?: TableSummaryConfig<T> | ((context: EditableTableSummaryContext<T>) => ReactNode);
-    /** Wraps a license-gated summary entry. Without it, gated entries render ungated. */
     renderLicense?: (license: SummaryLicenseConfig, children: ReactNode) => ReactNode;
-    /**
-     * Height of the scrolling body. Bounded on purpose: the header pins to its top
-     * and the totals row to its bottom, so however many rows are added both stay
-     * visible. Default `'min(70vh, 700px)'`.
-     */
     maxHeight?: number | string;
-    /**
-     * Keyboard policy for every cell. Merged over `GRID_CELL_KEYBOARD_DEFAULTS`,
-     * so a table names only what it wants to change — most often `editKey`,
-     * since the default `Insert` is absent from Mac and compact keyboards.
-     */
     keyboard?: FieldKeyboardConfig;
     [key: string]: any;
 }
@@ -203,11 +132,6 @@ export interface EditableTableRowProps<T = any> {
     columnFields: EditableTableColumnDefinition<any>[];
     editableTableData: T;
     onChange: (event: ChangeEvent<any>, rowIndex: number) => void;
-    /**
-     * @deprecated Cells reach the grid through `keyboard.onNavigate`, which the
-     * table sets once on a `FieldProvider`. Optional so a custom row renderer
-     * that still passes one keeps compiling.
-     */
     onKeyDown?: (event: KeyboardEvent<any>, rowIndex: number) => void;
     onSelect?: (selected: any, fieldName: string, rowIndex: number) => void;
     onCellFocus: (rowIndex: number, cellindex: number) => void;
@@ -216,11 +140,8 @@ export interface EditableTableRowProps<T = any> {
     isFocusedRow: boolean;
     focusedCellIndex: number | null;
     tableDataKey?: string;
-    /** Render prop for authorize — passed through to Fields */
     renderAuthorize?: (authorize: any, children: ReactNode) => ReactNode;
-    /** Render prop for tooltip — passed through to Fields */
     renderTooltip?: (tooltipProps: any, children: ReactNode) => ReactNode;
-    /** Component registry — passed through to Fields */
     componentRegistry?: any;
     [key: string]: any;
 }

package/dist/types/shared-types/src/ui/field.types.d.ts

@@ -3,46 +3,6 @@ import type { DataAttributes } from './common.types';
 import type { FieldTooltipSupport } from './fieldWrapper.types';
 import type { ControlLabelPosition, ControlLayout, ControlSize, ControlVariant, FieldCellContext, FieldChangeEvent, FieldColor, ToggleVariant } from './control.types';
 import type { FieldKeyboardConfig } from './keyboard.types';
-/**
- * The one field contract.
- *
- * `control.types` unified the *vocabulary* — `ControlSize`, `ControlVariant`,
- * `FieldChangeEvent` — so the values could no longer drift. It did not unify
- * the *shape*: all seven fields still spelled out their own prop lists by hand,
- * and they had already drifted apart in ways nothing could catch.
- *
- * What the audit found, before this file existed:
- *
- * - `name`, `label`, `size`, `disabled`, `readOnly`, `required`, `error`,
- *   `autoFocus`, `tabIndex`, `onFocus`, `onBlur` and `className` were
- *   re-declared by hand in **all seven** props files. Checkbox declared `name`
- *   three times, in three different sub-interfaces.
- * - `onFocus`/`onBlur` had **five different signatures**, and Select disagreed
- *   with itself: `onBlur: (e: SelectEvent)` beside `onFocus: (e: FocusEvent)`,
- *   declared 65 lines apart in two sub-interfaces.
- * - `onKeyDown` existed on **three of seven**. Checkbox, Radio, Switch and
- *   ChipInput could not participate in grid navigation at all.
- * - The helper line under a field was `hint` on Input/Suggest/ChipInput and
- *   `helperText` on Checkbox/Radio/Switch — for the same slot in the same
- *   FieldWrapper.
- * - `FieldCellContext` reached three of seven, and Select imported it under the
- *   alias `InputEditableTableCellProps` — named after a different component.
- *
- * Every axis below is declared **once**. A field's own props file holds only
- * what is genuinely its own; adding an axis later edits this file, not seven.
- */
-/**
- * `C` — the change event a field emits — is a parameter rather than a fixed
- * `FieldChangeEvent`, and deliberately so. Input, Suggest and the toggles
- * forward a **real DOM event**, so their consumers keep `currentTarget` and
- * `preventDefault()`; Select and ChipInput have no DOM event and emit the
- * synthetic shape. Fixing `C` to `FieldChangeEvent` would unify the declaration
- * by quietly taking capability away from five fields.
- *
- * A container still writes one handler for all of them: `FieldChangeEvent` is
- * what a DOM `ChangeEvent` structurally satisfies, so a handler typed against
- * the narrow shape is assignable to every field's `onChange`.
- */
 export interface FieldIdentityProps<V = any, C = FieldChangeEvent<V>> {
     id?: string;
     name?: string;
@@ -50,41 +10,20 @@ export interface FieldIdentityProps<V = any, C = FieldChangeEvent<V>> {
     defaultValue?: V;
     onChange?: (event: C) => void;
 }
-/**
- * What every field shares. Resolved by `useFieldSurface`
- * (own prop → FieldContext → default), never by a destructuring default.
- */
 export interface FieldSurfaceProps {
     size?: ControlSize;
     disabled?: boolean;
     readOnly?: boolean;
 }
-/** Fields that render a text-entry surface: Input, Select, Suggest, ChipInput. */
 export interface ControlSurfaceProps extends FieldSurfaceProps {
     variant?: ControlVariant;
     layout?: ControlLayout;
 }
-/**
- * The box-shaped toggles: Checkbox, Radio, Switch.
- *
- * Separate from `ControlSurfaceProps` on purpose. A toggle has no text line, so
- * `variant: 'underlined'` would type-check and render a box with neither border
- * nor fill, and `layout` has nothing to arrange — a toggle positions its label
- * with `labelPosition`. Handing toggles the text-field surface would make both
- * expressible and meaningless.
- */
 export interface ToggleSurfaceProps extends FieldSurfaceProps {
     variant?: ToggleVariant;
     color?: FieldColor;
     labelPosition?: ControlLabelPosition;
 }
-/**
- * The label / helper / error furniture, all of which FieldWrapper renders.
- *
- * `ReactNode` rather than `string` for label, hint and error: the toggles
- * already passed rich content through the wrapper while Input's types claimed
- * `string`, so the wrapper's real contract was the wider one.
- */
 export interface FieldChromeProps {
     label?: ReactNode;
     hint?: ReactNode;
@@ -95,83 +34,36 @@ export interface FieldChromeProps {
     style?: CSSProperties;
     fullWidth?: boolean;
 }
-/**
- * Re-declared per field before this existed, in four of the seven, with the
- * other three simply dropping them.
- */
 export interface FieldA11yProps {
     'aria-label'?: string;
     'aria-labelledby'?: string;
     'aria-describedby'?: string;
     'aria-required'?: boolean;
     'aria-invalid'?: boolean;
+    'aria-activedescendant'?: string;
+    'aria-controls'?: string;
 }
-/**
- * The focus event a container writes its handler against — the widest one, so
- * `Fields` can pass a single `onBlur` to all seven fields.
- */
 export type FieldFocusEvent = FocusEvent<HTMLElement>;
-/**
- * One focus/key signature, parameterised by the element the field actually
- * focuses — `HTMLInputElement` for Input and the toggles, `HTMLDivElement` for
- * Select's trigger, and so on.
- *
- * Parameterised rather than widened to a flat `HTMLElement` because widening
- * would break every consumer whose handler is annotated with the narrow event
- * type. A container's handler is unaffected either way: TypeScript checks
- * function parameters contravariantly, so a broadly-typed
- * `(e: KeyboardEvent) => void` — which is what the grid and form pass down —
- * remains assignable to every field's `onKeyDown`.
- */
 export interface FieldInteractionProps<E extends HTMLElement = HTMLElement> {
     autoFocus?: boolean;
     tabIndex?: number;
     onFocus?: (event: FocusEvent<E>) => void;
     onBlur?: (event: FocusEvent<E>) => void;
     onKeyDown?: (event: KeyboardEvent<E>) => void;
-    /** @see FieldKeyboardConfig — arrow/Enter/edit-key policy. */
     keyboard?: FieldKeyboardConfig;
 }
-/**
- * Why a popup opened or closed.
- *
- * A boolean is not enough for the grid. "Closed because the user picked an
- * option" must return the cell to navigate mode, while "closed because Escape"
- * must leave it in edit mode with the typed text intact — two different
- * behaviours that a bare `onOpenChange(false)` cannot distinguish.
- */
 export type OpenReason = 'type' | 'focus' | 'key' | 'click' | 'select' | 'escape' | 'blur' | 'programmatic';
-/**
- * Fields with a popup: Select, Suggest, and any date/lookup field added later.
- *
- * Before this, popup state was private to each component — only Select had
- * `onOpen`/`onClose`, neither field accepted `open`, and nothing could be
- * controlled from outside. The grid's rule that an open popup owns the arrow
- * keys had no state to read.
- */
 export interface FieldPopupProps {
-    /** Controlled. Omit for the field to own its own state. */
     open?: boolean;
     defaultOpen?: boolean;
     onOpenChange?: (open: boolean, reason: OpenReason) => void;
 }
-/**
- * What `ref` points at, for every field.
- *
- * It used to be four different DOM nodes and no behaviour, which is why the
- * editable table resorted to `document.querySelector('.smartselect-trigger')`
- * to move focus — there was no other way to focus a Select from outside it.
- *
- * `element` keeps the old capability available, so nothing that a DOM ref could
- * do becomes impossible.
- */
 export interface FieldHandle {
     focus(opts?: {
         select?: boolean;
         caret?: 'start' | 'end';
     }): void;
     blur(): void;
-    /** Navigate → edit. `seed` replaces the value, as type-to-replace does. */
     beginEdit(seed?: string): void;
     endEdit(commit: boolean): void;
     openPopup(reason?: OpenReason): void;
@@ -179,22 +71,10 @@ export interface FieldHandle {
     readonly isOpen: boolean;
     readonly element: HTMLElement | null;
 }
-/**
- * Everything every field has, whatever it renders.
- *
- * Surface is **not** included: text fields and toggles take different surface
- * axes (see `ControlSurfaceProps` / `ToggleSurfaceProps`), and merging them
- * would give a Checkbox a `layout` and an `underlined` variant that mean
- * nothing. Each field extends this plus the surface interface for its family.
- *
- * @typeParam V — the value type
- * @typeParam E — the element the field focuses
- * @typeParam C — the change event it emits
- */
 export type BaseFieldProps<V = any, E extends HTMLElement = HTMLElement, C = FieldChangeEvent<V>> = FieldIdentityProps<V, C> & FieldChromeProps & FieldA11yProps & FieldInteractionProps<E> & FieldCellContext & FieldTooltipSupport & DataAttributes;
-/** The text-entry families: Input, Select, Suggest, ChipInput. */
 export type TextFieldProps<V = any, E extends HTMLElement = HTMLElement, C = FieldChangeEvent<V>> = BaseFieldProps<V, E, C> & ControlSurfaceProps & {
     placeholder?: string;
+    inputMode?: 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url' | 'none';
+    spellCheck?: boolean;
 };
-/** The toggle family: Checkbox, Radio, Switch. */
 export type ToggleFieldProps<V = any, E extends HTMLElement = HTMLInputElement, C = FieldChangeEvent<V>> = BaseFieldProps<V, E, C> & ToggleSurfaceProps;

package/dist/types/shared-types/src/ui/fieldWrapper.types.d.ts

@@ -1,26 +1,16 @@
 import { CSSProperties, ReactNode, Ref } from 'react';
 import type { TooltipProp, TooltipTrigger } from './tooltip.types';
 import type { ControlLayout, ControlSize, ControlVariant } from './control.types';
-/** @see ControlLayout — the shared vocabulary in `control.types`. */
 export type FieldLayout = ControlLayout;
-/** @see ControlSize — the shared vocabulary in `control.types`. */
 export type FieldSize = ControlSize;
-/** @see ControlVariant — the shared vocabulary in `control.types`. */
 export type FieldVariant = ControlVariant;
 export type { ToggleVariant } from './control.types';
-/**
- * Every control that renders through FieldWrapper accepts these, so a tooltip
- * behaves identically on an Input, a Select or a Checkbox.
- */
 export interface FieldTooltipSupport {
     tooltip?: TooltipProp;
-    /** `icon` (default) puts a ⓘ after the label; `control` uses the field itself. */
     tooltipTrigger?: TooltipTrigger;
 }
 export interface FieldWrapperProps extends FieldTooltipSupport {
     label?: ReactNode;
-    /** ReactNode, not string: Checkbox/Radio/Switch allow rich error and helper
-        content, and they render their messages through this wrapper too. */
     error?: ReactNode;
     hint?: ReactNode;
     required?: boolean;

package/dist/types/shared-types/src/ui/fields.types.d.ts

@@ -48,30 +48,10 @@ export type ConditionRegexObject<T> = {
 export type ConditionFunction<T> = (data: T, context?: ConditionContext) => boolean;
 export type ConditionSimpleKey<T> = NestedKeys<T>;
 export type Condition<T> = boolean | ConditionSimpleKey<T> | ConditionObject<T> | ConditionRegexObject<T> | ConditionFunction<T> | Array<ConditionSimpleKey<T> | ConditionObject<T> | ConditionRegexObject<T> | ConditionFunction<T>>;
-/**
- * One rule on one cell.
- *
- * Rules are **per cell and dynamic**, not per row and not static: a minimum-quantity rule
- * belongs on Qty and S.Qty but not on Price, and it may not apply at all depending on other
- * settings ("unsaved items allowed" switches the item rule off). So a rule speaks the same
- * `Condition` vocabulary `disabled` and `render` already use — it sees the whole row, the
- * defaults and the cell's position, and it can be a plain function when that is simpler.
- */
 export interface CellRule<T> {
-    /** When this rule APPLIES at all. Omitted = always. */
     when?: Condition<T>;
-    /** The cell is VALID while this holds. */
     valid: Condition<T>;
-    /** Shown on the cell itself — red edge, message in the control's tooltip. */
     message: string;
-    /**
-     * `'block'` (default) also traps in-grid keyboard movement in the cell until it is valid,
-     * and refuses a new row. `'warn'` only marks it.
-     *
-     * Neither severity hijacks the mouse, Tab out of the grid, or Escape: a pointer cannot be
-     * trapped without fighting the browser, so an invalid cell keeps its mark and blocks what
-     * it can — the next row, and the consumer's save.
-     */
     severity?: 'block' | 'warn';
 }
 export interface ConditionContext {
@@ -130,30 +110,17 @@ export interface EditableTableCustomPropContext<T> extends FieldEditableTablePro
     basePath: string;
     field: FieldDefinition<T>;
 }
-/**
- * What a cell can ask its table to DO.
- *
- * Handed to a button cell's `onClick` so the button can act on its own row — delete it,
- * copy it, write back what a modal returned — without the column definition closing over
- * the table's state. Optional to use; a button that only reads `rowData` ignores it.
- */
 export interface EditableTableCellActions {
     addRow: (insertIndex?: number) => void;
     copyRow: (insertIndex?: number) => void;
     deleteRow: (rowIndex?: number) => void;
     focusCell: (rowIndex: number, cellindex: number) => void;
-    /** Merge a patch into one row — the write-back path for a modal or a lookup. */
     updateRow: (rowIndex: number, patch: Record<string, any>) => void;
 }
-/**
- * Everything a button cell knows about where it was pressed. One argument, so a handler
- * that needs none of it stays `() => doThing()`.
- */
 export interface ButtonCellContext<T> {
     rowIndex: number;
     cellindex: number;
     rowData: any;
-    /** This column's own value in that row, when the column names one. */
     value: any;
     tableData: any[];
     actions: EditableTableCellActions;
@@ -169,13 +136,7 @@ export interface FieldEditableTableProps<T> {
     onCellFocus?: (rowIndex: number, cellindex: number) => void;
     registerCellRef: (rowIndex: number, cellindex: number, ref: any) => void;
     onSelect?: (...args: any[]) => void;
-    /** The table's own row operations, for cells that act (see `EditableTableCellActions`). */
     actions?: EditableTableCellActions;
-    /**
-     * @deprecated A cell reaches its container through `keyboard.onNavigate`,
-     * which the grid sets once on a `FieldProvider`. Optional so a custom row
-     * renderer that still supplies one keeps compiling.
-     */
     onKeyDown?: (event: any) => void;
     [key: string]: any;
 }
@@ -184,7 +145,6 @@ export interface BaseFieldDefinition<T> {
     header?: string;
     render?: Condition<T>;
     disabled?: Condition<T>;
-    /** Validation for THIS cell — see `CellRule`. Evaluated per row, in order; first failure wins. */
     rules?: Array<CellRule<T>>;
     authorize?: FieldAuthorize;
     tooltip?: FieldTooltipProps;
@@ -226,11 +186,6 @@ export interface CheckboxFieldDefinition<T> extends BaseFieldDefinition<T> {
 export interface ButtonFieldDefinition<T> extends BaseFieldDefinition<T> {
     field: 'button';
     fprop?: Partial<ButtonProps>;
-    /**
-     * Column-level click, with the row/cell context and the table's actions — the generic
-     * form, since a button in row 7 must not need a column definition built for row 7.
-     * `fprop.onClick` still works and still receives only the DOM event.
-     */
     onClick?: (context: ButtonCellContext<T>) => void;
 }
 export interface ChildFieldDefinition<T> extends BaseFieldDefinition<T> {