@dcs-tech/ui 0.2.0 → 0.4.0

package/dist/types/core/types/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 → core/types}/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/core/types/field.types.d.ts

@@ -0,0 +1,80 @@
+import type { CSSProperties, FocusEvent, KeyboardEvent, ReactNode } from 'react';
+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';
+export interface FieldIdentityProps<V = any, C = FieldChangeEvent<V>> {
+    id?: string;
+    name?: string;
+    value?: V;
+    defaultValue?: V;
+    onChange?: (event: C) => void;
+}
+export interface FieldSurfaceProps {
+    size?: ControlSize;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+export interface ControlSurfaceProps extends FieldSurfaceProps {
+    variant?: ControlVariant;
+    layout?: ControlLayout;
+}
+export interface ToggleSurfaceProps extends FieldSurfaceProps {
+    variant?: ToggleVariant;
+    color?: FieldColor;
+    labelPosition?: ControlLabelPosition;
+}
+export interface FieldChromeProps {
+    label?: ReactNode;
+    hint?: ReactNode;
+    error?: ReactNode;
+    required?: boolean;
+    className?: string;
+    labelClassName?: string;
+    style?: CSSProperties;
+    fullWidth?: boolean;
+}
+export interface FieldA11yProps {
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+    'aria-required'?: boolean;
+    'aria-invalid'?: boolean;
+    'aria-activedescendant'?: string;
+    'aria-controls'?: string;
+}
+export type FieldFocusEvent = FocusEvent<HTMLElement>;
+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;
+    keyboard?: FieldKeyboardConfig;
+}
+export type OpenReason = 'type' | 'focus' | 'key' | 'click' | 'select' | 'escape' | 'blur' | 'programmatic';
+export interface FieldPopupProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean, reason: OpenReason) => void;
+}
+export interface FieldHandle {
+    focus(opts?: {
+        select?: boolean;
+        caret?: 'start' | 'end';
+    }): void;
+    blur(): void;
+    beginEdit(seed?: string): void;
+    endEdit(commit: boolean): void;
+    openPopup(reason?: OpenReason): void;
+    closePopup(reason?: OpenReason): void;
+    readonly isOpen: boolean;
+    readonly element: HTMLElement | null;
+}
+export type BaseFieldProps<V = any, E extends HTMLElement = HTMLElement, C = FieldChangeEvent<V>> = FieldIdentityProps<V, C> & FieldChromeProps & FieldA11yProps & FieldInteractionProps<E> & FieldCellContext & FieldTooltipSupport & DataAttributes;
+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;
+};
+export type ToggleFieldProps<V = any, E extends HTMLElement = HTMLInputElement, C = FieldChangeEvent<V>> = BaseFieldProps<V, E, C> & ToggleSurfaceProps;

package/dist/types/{shared-types/src/ui → core/types}/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 → core/types}/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> {

package/dist/types/{shared-types/src/ui → core/types}/form.types.d.ts

@@ -4,8 +4,6 @@ import type { FieldDefinition, ErrorObject, TouchedObject } from './fields.types
 import type { ControlSize } from './control.types';
 import type { FieldKeyboardConfig } from './keyboard.types';
 export type FormLayout = 'vertical' | 'horizontal' | 'grid' | 'inline';
-/** @see ControlSize — a Form's size is the density every field inside it
-    inherits, so it has to span the same six steps the fields do. */
 export type FormSize = ControlSize;
 export type FormVariant = 'default' | 'card' | 'outlined' | 'elevated';
 export interface FormSection<T = any> {
@@ -24,20 +22,13 @@ export interface FormSection<T = any> {
     style?: CSSProperties;
 }
 export interface FormValidation<T = any> {
-    /** Validation schema (e.g. Yup schema) — passed to validate function */
     schema?: any;
     validateOnChange?: boolean;
     validateOnBlur?: boolean;
     validateOnSubmit?: boolean;
     debounceMs?: number;
-    /** Custom validation function (runs after schema validation) */
     customValidator?: (data: T) => Promise<ErrorObject> | ErrorObject;
     showErrorsAfterTouched?: boolean;
-    /**
-     * App-provided validation function.
-     * Called with (schema, data) — should return { valid, errors }.
-     * Decouples the form from any specific validation library (Yup, Zod, etc).
-     */
     validate?: (schema: any, data: T) => Promise<{
         valid: boolean;
         errors: ErrorObject;
@@ -87,9 +78,7 @@ export interface FormHeader {
     subtitle?: string | ReactNode;
     icon?: ReactNode;
     divider?: boolean;
-    /** Navigation link — app provides onNavigate callback to handle it */
     navLink?: string;
-    /** Icon for the nav link button */
     navIcon?: ReactNode;
     actions?: ReactNode;
     customHeader?: ReactNode;
@@ -102,12 +91,6 @@ export interface FormFooter {
     className?: string;
 }
 export interface FormCallbacks<T = any> {
-    /**
-     * The generic here used to sit on the *implementer* — `<R = void>(...) => R | Promise<R>`
-     * — which meant the caller chose `R` and no ordinary callback could satisfy
-     * it: `onSubmit={(data) => {...}}` did not type-check without a cast. The
-     * return value is awaited and discarded, so the generic bought nothing.
-     */
     onSubmit?: (data: T, methods: FormMethods<T>, event?: FormEvent<HTMLFormElement>) => unknown;
     onReset?: (methods: FormMethods<T>) => void;
     onChange?: (data: T, changedField?: string, methods?: FormMethods<T>) => void;
@@ -115,9 +98,7 @@ export interface FormCallbacks<T = any> {
     onError?: (errors: ErrorObject, methods: FormMethods<T>) => void;
     onValidationSuccess?: (methods: FormMethods<T>) => void;
     onUnhandledError?: (error: Error, methods: FormMethods<T>) => void;
-    /** Toast callback — replaces direct ReactToast import. Called with (type, message). */
     onToast?: (type: 'success' | 'error' | 'info' | 'warning', message: string) => void;
-    /** Navigation callback — replaces direct useNavigate import. Called with (path). */
     onNavigate?: (path: string) => void;
 }
 export interface FormProps<T = any> extends FormCallbacks<T> {
@@ -144,13 +125,6 @@ export interface FormProps<T = any> extends FormCallbacks<T> {
     loadingMessage?: string;
     disabled?: boolean;
     readonly?: boolean;
-    /**
-     * The keyboard policy for every field in this form.
-     *
-     * `{ enter: 'next' }` gives traditional ERP entry — Enter walks the fields
-     * and, past the last one, submits; Ctrl+Enter submits from anywhere. The
-     * default stays `'submit'`, which is what a `<form>` does on the web.
-     */
     keyboard?: FieldKeyboardConfig;
     formRef?: MutableRefObject<FormMethods<T> | null>;
     children?: ReactNode | ((data: T, methods: FormMethods<T>) => ReactNode);
@@ -164,13 +138,9 @@ export interface FormProps<T = any> extends FormCallbacks<T> {
     requiredIndicator?: ReactNode;
     enableNestedFields?: boolean;
     debug?: boolean;
-    /** Render prop for loading overlay — replaces direct FullPageLoading import */
     renderLoading?: (isOpen: boolean, message?: string) => ReactNode;
-    /** Render prop for authorize wrapping — passed through to Fields */
     renderAuthorize?: (authorize: any, children: ReactNode) => ReactNode;
-    /** Render prop for tooltip wrapping — passed through to Fields */
     renderTooltip?: (tooltipProps: any, children: ReactNode) => ReactNode;
-    /** Component registry — passed through to Fields */
     componentRegistry?: any;
 }
 export interface FormState<T = any> {

package/dist/types/core/types/index.d.ts

@@ -0,0 +1,22 @@
+export * from './control.types';
+export * from './tooltip.types';
+export * from './typography.types';
+export * from './button.types';
+export * from './fieldWrapper.types';
+export * from './keyboard.types';
+export * from './field.types';
+export * from './checkbox.types';
+export * from './radio.types';
+export * from './switch.types';
+export * from './input.types';
+export * from './datePicker.types';
+export * from './select.types';
+export * from './suggest.types';
+export * from './collapsible.types';
+export * from './fields.types';
+export * from './form.types';
+export * from './chipinput.types';
+export * from './table.types';
+export * from './editableTable.types';
+export * from './navigation.types';
+export type { DataAttributes } from './common.types';

package/dist/types/{shared-types/src/ui → core/types}/input.types.d.ts

@@ -21,10 +21,6 @@ export interface IconConfig {
     end?: ReactNode;
     onClick?: (type: 'start' | 'end') => void;
 }
-/**
- * @see FieldCellContext — the one grid-cell contract, in `control.types`.
- * Kept as a name because Select imports it and the published barrel exports it.
- */
 export type InputEditableTableCellProps = FieldCellContext;
 export interface InputProps extends TextFieldProps<string | number, HTMLInputElement | HTMLTextAreaElement, ChangeEvent<HTMLInputElement | HTMLTextAreaElement>> {
     type?: InputType;

package/dist/types/core/types/keyboard.types.d.ts

@@ -0,0 +1,48 @@
+export type FieldWidget = 'text' | 'number' | 'textarea' | 'select' | 'suggest' | 'date' | 'toggle' | 'button' | 'custom';
+export type NavAction = 'next' | 'prev' | 'up' | 'down' | 'left' | 'right' | 'firstCell' | 'lastCell' | 'firstCellOfTable' | 'lastCellOfTable' | 'pageUp' | 'pageDown' | 'newRow' | 'copyRow' | 'deleteRow' | 'edit' | 'commit' | 'revert' | 'clear' | 'submit' | 'exitGrid' | 'none';
+export type GridMode = 'navigate' | 'edit';
+export interface FieldKeyState {
+    mode: GridMode;
+    isOpen: boolean;
+    hasOptions?: boolean;
+    caretAtStart?: boolean;
+    caretAtEnd?: boolean;
+    hasSelection?: boolean;
+    isEmpty?: boolean;
+    multi?: boolean;
+}
+export interface KeyEventLike {
+    key: string;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+}
+export type FieldKeyAction = 'native' | 'open' | 'close' | 'highlightNext' | 'highlightPrev' | 'highlightFirst' | 'highlightLast' | 'highlightLeft' | 'highlightRight' | 'highlightPrevPage' | 'highlightNextPage' | 'pick' | 'toggleOption' | 'beginEdit' | 'clear' | 'stepUp' | 'stepDown' | 'insertNewline';
+export type KeyResolution = {
+    owner: 'field';
+    action: FieldKeyAction;
+    preventDefault: boolean;
+} | {
+    owner: 'container';
+    action: NavAction;
+    preventDefault: boolean;
+};
+export interface FieldKeyboardConfig {
+    mode?: 'field' | 'grid';
+    enter?: 'next' | 'submit' | 'native' | 'none';
+    arrows?: 'container' | 'native';
+    arrowsInEdit?: 'cell' | 'caret';
+    typeBehaviour?: 'replace' | 'append';
+    editKey?: string;
+    openOn?: 'focus' | 'type' | 'manual';
+    advanceOnSelect?: boolean;
+    stepKeys?: 'none' | 'arrows' | 'ctrlArrows';
+    bindings?: Record<string, NavAction>;
+    onNavigate?: (action: NavAction, event: KeyEventLike) => void;
+}
+export interface KeyResolutionContext {
+    widget: FieldWidget;
+    state: FieldKeyState;
+    config: FieldKeyboardConfig;
+}

package/dist/types/core/types/navigation.types.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+export interface NavItem {
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    badge?: ReactNode;
+    keywords?: string;
+    disabled?: boolean;
+    href?: string;
+    props?: Record<string, unknown>;
+    children?: NavItem[];
+    group?: boolean;
+}

package/dist/types/{shared-types/src/ui → core/types}/radio.types.d.ts

@@ -19,13 +19,7 @@ export interface RadioGroupContextValue {
 export interface RadioProps extends ToggleFieldProps<string | number, HTMLInputElement, ChangeEvent<HTMLInputElement>> {
     checked?: boolean;
     defaultChecked?: boolean;
-    /** Required here, unlike every other field: a radio without a value cannot
-        report which option it is. */
     value: string | number;
-    /**
-     * @deprecated Use `hint` — the shared name for this slot, which is what
-     * FieldWrapper renders. Kept until the components migrate (step 0c).
-     */
     helperText?: string | ReactNode;
     radioClassName?: string;
     checkedIcon?: ReactNode;