@dcs-tech/ui 0.2.0 → 0.3.0

package/dist/types/shared-types/src/ui/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/shared-types/src/ui/index.d.ts

@@ -1,19 +1,3 @@
-/**
- * The UI half of `shared-types`, on its own — a privacy boundary, like its twin in
- * `shared-logic/src/ui/index.ts`.
- *
- * The package barrel (`shared-types/src/index.ts`) re-exports this folder alongside the
- * folders describing this business's own records. Anything importing the barrel pulls all of
- * it into the TypeScript program, and `tsc` emits
- * declarations for a whole program, so the domain then ships wherever those declarations do.
- * That is how `@dcs-tech/ui@0.1.0` reached the public registry carrying them (audited
- * 2026-09-28).
- *
- * `navigation.types` and `common.types` are included because the app-shell components are
- * published and typed against them; neither describes any business record.
- *
- * ONLY `./ui/*` belongs here. Never add a domain module, and never re-export the parent barrel.
- */
 export * from './control.types';
 export * from './tooltip.types';
 export * from './typography.types';
@@ -25,6 +9,7 @@ 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';

package/dist/types/shared-types/src/ui/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/shared-types/src/ui/keyboard.types.d.ts

@@ -1,59 +1,16 @@
-/**
- * The keyboard contract — one truth table for every field, in every container.
- *
- * Key handling used to be **field-first**: each field ran its own `handleKeyDown`
- * and *might* forward what was left to the container. Three incompatible rules
- * had grown out of that:
- *
- * - Input had no key logic at all, so the grid could only use keys an input
- *   ignores — which is why the editable table navigated on **Ctrl/Alt+Arrow**
- *   instead of the plain arrows every native ERP grid uses.
- * - Suggest swallowed ArrowUp/ArrowDown/Enter/Escape unconditionally, open or
- *   closed, so a closed suggest cell ate the grid's arrows.
- * - Select kept an ad-hoc allow-list of keys to forward *and* a boolean return
- *   from its hook — two arbitration mechanisms inside one component.
- *
- * Which key reached the grid therefore depended on which widget a cell happened
- * to hold, and no truth table existed to test against.
- *
- * This inverts it. The **container arbitrates**; a field only reports what it
- * currently needs, and one pure resolver decides. A field author never writes
- * key handling — they spread the handlers `useField` returns.
- */
-/**
- * What kind of keyboard behaviour a field has. Not the same as the component:
- * a number Input and a text Input are one component and two widgets, because
- * they answer differently on the arrow keys.
- */
-export type FieldWidget = 'text' | 'number' | 'textarea' | 'select' | 'suggest' | 'toggle'
-/** A cell that ACTS instead of holding a value: Space presses it, Enter walks on. */
- | 'button' | 'custom';
-/** What the container is being asked to do. */
+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';
-/** Which half of the cell's two-mode state is live. @see FIELD_KEYBOARD_NAVIGATION.md §2 */
 export type GridMode = 'navigate' | 'edit';
-/**
- * The live field state the resolver needs. Everything here is knowable without
- * touching the DOM at the point of decision, which is what keeps the resolver
- * pure and its truth table runnable under plain Node.
- */
 export interface FieldKeyState {
     mode: GridMode;
     isOpen: boolean;
-    /** A popup with nothing in it must not swallow Enter. */
     hasOptions?: boolean;
     caretAtStart?: boolean;
     caretAtEnd?: boolean;
     hasSelection?: boolean;
     isEmpty?: boolean;
-    /** Multi-select keeps its popup open on Enter where single-select closes it. */
     multi?: boolean;
 }
-/**
- * A `React.KeyboardEvent` satisfies this structurally — the same trick
- * `FieldChangeEvent` uses. The resolver takes the minimum so it can live in
- * shared-logic with no React or DOM import, and stay mechanically portable.
- */
 export interface KeyEventLike {
     key: string;
     ctrlKey?: boolean;
@@ -61,21 +18,7 @@ export interface KeyEventLike {
     altKey?: boolean;
     metaKey?: boolean;
 }
-/** What the field does with a key it keeps. */
-export type FieldKeyAction = 'native' | 'open' | 'close' | 'highlightNext' | 'highlightPrev' | 'highlightFirst' | 'highlightLast' | 'pick' | 'toggleOption' | 'beginEdit' | 'clear' | 'stepUp' | 'stepDown'
-/**
- * Put a line break in a multi-line cell (Alt+Enter, the Excel/Sheets convention).
- *
- * It needs an action of its own because a grid has no spare Enter: plain Enter moves to the
- * next cell, Shift+Enter to the previous one, Ctrl+Enter adds a row. Alt+Enter is the one
- * combination left, and the browser inserts nothing for it on its own — so unlike every
- * other textual key this cannot resolve to `'native'`.
- */
- | 'insertNewline';
-/**
- * Exactly one owner per key, always. A resolution that named neither owner is
- * how keys used to go missing between a field and its container.
- */
+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;
@@ -85,69 +28,19 @@ export type KeyResolution = {
     action: NavAction;
     preventDefault: boolean;
 };
-/**
- * How a field or container behaves on the keyboard.
- *
- * This is the **Interaction axis** of `BaseFieldProps`, so it lands on all seven
- * fields at once rather than the three that happen to have `onKeyDown` today.
- * A container sets it once through `FieldContext` and every field beneath obeys;
- * resolution is the same own prop → provider → default order as `size`.
- */
 export interface FieldKeyboardConfig {
-    /**
-     * `'field'` — an ordinary standalone field; the browser's behaviour, plus
-     * whatever `enter` says.
-     * `'grid'` — the two-mode navigate/edit model a cell needs.
-     */
     mode?: 'field' | 'grid';
-    /**
-     * What Enter does when no popup is open.
-     *
-     * The library default is `'submit'`, because a `<form>` submitting on Enter
-     * is the web standard and this package is published. Our apps set `'next'`
-     * once on the provider: traditional ERP data entry moves on Enter and
-     * submits on Ctrl+Enter or the action button.
-     */
     enter?: 'next' | 'submit' | 'native' | 'none';
-    /** Arrow keys in navigate mode. `'container'` moves between cells. */
     arrows?: 'container' | 'native';
-    /**
-     * Up/Down while editing. `'cell'` commits and moves row — Sheets' "enter
-     * mode", which is what makes column-down entry fast. `'caret'` leaves them
-     * to the browser; a textarea forces this regardless.
-     */
     arrowsInEdit?: 'cell' | 'caret';
-    /** Navigate + a printable key. `'replace'` wipes the old value; `'append'` keeps it. */
     typeBehaviour?: 'replace' | 'append';
-    /**
-     * Navigate → edit **without** wiping the value — the "alter" key, as
-     * against type-to-replace. Default `'Insert'`.
-     *
-     * A binding string rather than a fixed key so any table or form overrides it
-     * for its own audience: `Insert` is absent from Mac keyboards and most
-     * compact laptops, and those consumers pass `'F2'` or `'alt+enter'`.
-     */
     editKey?: string;
-    /**
-     * When a popup opens. `'focus'` is right for a standalone field and wrong in
-     * a grid, where arrowing across a row would pop a list in every cell.
-     */
     openOn?: 'focus' | 'type' | 'manual';
-    /** After picking from a popup: stay in the cell (default), or move on like Enter. */
     advanceOnSelect?: boolean;
-    /**
-     * Whether Up/Down step a number's value. `'none'` everywhere by default —
-     * in a grid the arrows belong to navigation, and a key that silently edits
-     * a number while the user believes they are moving is a data-integrity bug,
-     * not a convenience.
-     */
     stepKeys?: 'none' | 'arrows' | 'ctrlArrows';
-    /** Overrides, keyed by binding string: `{ 'ctrl+enter': 'newRow' }`. */
     bindings?: Record<string, NavAction>;
-    /** Supplied by the container, never by a consumer. */
     onNavigate?: (action: NavAction, event: KeyEventLike) => void;
 }
-/** Everything `resolveFieldKey` needs, and nothing it does not. */
 export interface KeyResolutionContext {
     widget: FieldWidget;
     state: FieldKeyState;

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

@@ -1,35 +1,13 @@
 import type { ReactNode } from 'react';
-/**
- * One entry in a navigation structure — a sidebar row, a breadcrumb, a palette result, a tab.
- *
- * ONE shape on purpose. An app builds its route registry once and feeds Sidebar, Breadcrumbs
- * and CommandPalette from the same array, instead of three parallel structures that drift.
- * Nothing here knows where the items came from, which is exactly what makes a registry that
- * changes at runtime — per-business reports generated from `businesses × templates` — work
- * with no special support: it is just a different array.
- */
 export interface NavItem {
-    /** Stable identity. Used for the active match and as the React key. */
     id: string;
     label: ReactNode;
     icon?: ReactNode;
-    /** Trailing marker — a count, a status dot. */
     badge?: ReactNode;
-    /** Extra terms for search surfaces (CommandPalette). Not rendered. */
     keywords?: string;
     disabled?: boolean;
-    /** Plain link target. */
     href?: string;
-    /**
-     * Extra props spread onto the rendered element — how a router link gets its target,
-     * e.g. `{ to: '/reports/monthly/sales' }` with `as={NavLink}`. Router-agnostic on purpose.
-     */
     props?: Record<string, unknown>;
-    /** Nested entries. Depth is not assumed anywhere. */
     children?: NavItem[];
-    /**
-     * Render as a non-interactive section heading rather than a link. Its `children` still
-     * render beneath it.
-     */
     group?: boolean;
 }

package/dist/types/shared-types/src/ui/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;

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

@@ -60,15 +60,6 @@ export interface VirtualScrollConfig {
     overscan?: number;
     maxHeight?: number;
 }
-/**
- * @deprecated Superseded by `FieldKeyboardConfig`, which every field now takes.
- *
- * All six were per-component restatements of decisions the shared resolver
- * makes: `preventEnter`/`preventEnterToOpen`/`selectOnEnter` are what Enter does
- * given the popup state, `closeOnEscape`/`closeOnTab` are what Escape and Tab
- * do, and `navigateWithArrows` is law L1. They are accepted and ignored so
- * existing call sites keep compiling; nothing reads them.
- */
 export interface KeyboardConfig {
     preventEnter?: boolean;
     preventEnterToOpen?: boolean;
@@ -96,10 +87,6 @@ export interface LoadingConfig {
     loadingText?: string;
     renderLoadingState?: () => ReactNode;
 }
-/**
- * @deprecated Superseded by `FieldA11yProps` in `field.types`, which every field
- * now gets from `BaseFieldProps`. Kept because the published barrel exports it.
- */
 export interface SelectAccessibilityConfig {
     'aria-label'?: string;
     'aria-labelledby'?: string;
@@ -107,19 +94,9 @@ export interface SelectAccessibilityConfig {
     'aria-required'?: boolean;
     'aria-invalid'?: boolean;
 }
-/**
- * Select has no DOM event to forward, so it emits the shared shape directly.
- *
- * It used to carry `target.attributes.cellindex.value`, mimicking a DOM node so
- * a grid could read the cell back off the event. Nothing ever read it — the
- * grid tracks focus through `onCellFocus` — and its presence meant a handler
- * typed for any other field could not be passed to a Select. Removing it is
- * what makes one `(e: FieldChangeEvent) => void` work across the whole family.
- */
 export type SelectEvent = FieldChangeEvent<any>;
 export interface SelectProps extends TextFieldProps<any, HTMLDivElement, SelectEvent>, FieldPopupProps {
     options: (string | number | SelectOption)[];
-    /** Required, unlike the base: a Select that cannot report a choice is inert. */
     onChange: (event: SelectEvent) => void;
     defaultText?: string;
     autoFocusSearch?: boolean;
@@ -130,15 +107,6 @@ export interface SelectProps extends TextFieldProps<any, HTMLDivElement, SelectE
     reorder?: boolean | ReorderConfig;
     group?: boolean | GroupConfig;
     virtualScroll?: boolean | VirtualScrollConfig;
-    /**
-     * The shared policy, intersected with Select's own six booleans.
-     *
-     * `KeyboardConfig`'s members are all expressible in `FieldKeyboardConfig`
-     * — `preventEnter`, `selectOnEnter` and `navigateWithArrows` are exactly the
-     * per-widget rules the shared resolver owns — so this intersection is the
-     * transition state, not the destination. Step 0c folds the six in and
-     * deletes `KeyboardConfig`.
-     */
     keyboard?: FieldKeyboardConfig & KeyboardConfig;
     position?: DropdownPosition | PositionConfig;
     emptyState?: EmptyStateConfig;
@@ -159,9 +127,7 @@ export interface SelectProps extends TextFieldProps<any, HTMLDivElement, SelectE
     renderOption?: (option: SelectOption, isSelected: boolean, isHighlighted: boolean) => ReactNode;
     renderSelectedValue?: (value: any | any[], options: SelectOption[]) => ReactNode;
     renderChip?: (option: SelectOption, onRemove: () => void) => ReactNode;
-    /** @deprecated Use `onOpenChange`, which reports *why* — the grid needs the reason. */
     onOpen?: () => void;
-    /** @deprecated Use `onOpenChange`. */
     onClose?: () => void;
     onSearch?: (searchTerm: string) => void;
     onSelect?: (value: any) => void;
@@ -194,17 +160,10 @@ export interface UseSelectReturn {
         handleToggle: () => void;
         handleSelect: (option: SelectOption) => void;
         handleMultiSelect: (option: SelectOption) => void;
-        /**
-         * Highlight primitives, driven by `resolveFieldKey` through `useField`.
-         * They replace a `handleKeyDown` that returned a boolean telling the
-         * parent whether to also handle the key — the second of this
-         * component's two arbitration mechanisms.
-         */
         highlightNext: () => void;
         highlightPrev: () => void;
         highlightFirst: () => void;
         highlightLast: () => void;
-        /** @returns whether an option was actually picked. */
         pickHighlighted: () => boolean;
         handleSearchChange: (event: ChangeEvent<HTMLInputElement>) => void;
         handleClickOutside: (event: MouseEvent) => void;

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

@@ -47,9 +47,7 @@ export interface SuggestionItemProps {
 export interface SuggestionListProps<T = any> {
     suggestions: T[];
     renderKeys: RenderKey[];
-    /** Drives the shared popup list's size variables. Defaults to `small`. */
     size?: SuggestSize;
-    /** Decides the popup's shape — joined to a boxed field, or a floating panel. */
     variant?: SuggestVariant;
     onSelect: (item: T) => void;
     highlightedIndex: number;
@@ -72,9 +70,7 @@ export interface SuggestionListProps<T = any> {
 export interface SuggestProps extends TextFieldProps<string, HTMLInputElement, ChangeEvent<HTMLInputElement>>, FieldPopupProps {
     data: any[];
     config: SuggestionConfig;
-    /** Required, unlike the base: a Suggest with no value has nothing to search on. */
     value: string;
-    /** Required, unlike the base: a Suggest that cannot report typing is inert. */
     onChange: (event: ChangeEvent<HTMLInputElement>) => void;
     onSelect?: (item: any, inputName?: string) => void;
     onClear?: () => void;
@@ -119,16 +115,10 @@ export interface UseSuggestReturn {
     loading: boolean;
     handleInputChange: (event: ChangeEvent<HTMLInputElement>) => void;
     handleSelect: (item: any, index: number) => void;
-    /**
-     * Highlight primitives, driven by `resolveFieldKey` through `useField`.
-     * These replace the hook's old `handleKeyDown`, which claimed the arrow keys
-     * whether or not the list was open.
-     */
     highlightNext: () => void;
     highlightPrev: () => void;
     highlightFirst: () => void;
     highlightLast: () => void;
-    /** @returns whether an item was actually picked. */
     pickHighlighted: () => boolean;
     handleFocus: () => void;
     handleBlur: () => void;

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

@@ -8,10 +8,6 @@ export type SwitchColor = FieldColor;
 export interface SwitchProps extends ToggleFieldProps<string | number, HTMLInputElement, ChangeEvent<HTMLInputElement>> {
     checked?: boolean;
     defaultChecked?: boolean;
-    /**
-     * @deprecated Use `hint` — the shared name for this slot, which is what
-     * FieldWrapper renders. Kept until the components migrate (step 0c).
-     */
     helperText?: string | ReactNode;
     onText?: string;
     offText?: string;

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

@@ -1,17 +1,4 @@
 import type { ReactNode } from 'react';
-/**
- * The table vocabulary, shared.
- *
- * These are the client `Table`'s own column and summary props
- * (`apps/web/client/src/Utils/CustomElements/Table/types.ts`), lifted into the
- * shared layer so the editable table can speak the same language. A developer
- * who has configured a report table already knows every name here — `width`,
- * `minWidth`, `align`, `sticky`, `summable`, `summary`, `cell`, `cellStyle` —
- * and a summary written for a report table works on an editable one unchanged.
- *
- * The rule the editable table follows: **everything is a prop, and where the
- * Table already has a prop for something, use that exact prop.**
- */
 export type ColumnAlign = 'left' | 'center' | 'right';
 export type ColumnSticky = 'left' | 'right';
 export interface CellStyle {
@@ -31,11 +18,6 @@ export interface ColumnSummaryConfig<T = any> {
     filter?: (row: T) => boolean;
     formatter?: (value: number, rows: T[]) => string;
 }
-/**
- * What a summary `compute` receives. Shaped like the Table's context so a
- * summary written there runs here; the members an editable table has no
- * equivalent for (selection, filters) are optional.
- */
 export interface SummaryContext {
     allRows: any[];
     visibleColumns: string[];
@@ -43,7 +25,6 @@ export interface SummaryContext {
     filters?: unknown[];
     context?: Record<string, any>;
 }
-/** The Table names this `LicenseConfig`; renamed here only to avoid a barrel collision. */
 export interface SummaryLicenseConfig {
     tab: string;
     subtab: string;
@@ -52,12 +33,6 @@ export interface SummaryLicenseConfig {
 export interface SummaryItem<T = any> {
     id: string;
     label: string;
-    /**
-     * `resolved` carries every column total and every earlier item, keyed by id —
-     * so *average cost = total cost / total qty* reads the column totals rather
-     * than recomputing them. Column totals use the Table's id scheme,
-     * `col_<column>_<type>`, unless the column's summary names its own `id`.
-     */
     compute: (data: T[], context: SummaryContext, resolved: Record<string, number | string>) => string | number;
     format?: SummaryFormat;
     decimals?: number;
@@ -81,7 +56,6 @@ export interface SummaryGroupKey {
     formatter?: (value: any) => string;
     bold?: boolean;
     color?: string;
-    /** Force-hide. Left unset, a key the group's `compute` omitted is hidden automatically. */
     hidden?: boolean;
 }
 export interface SummaryGroup<T = any> {
@@ -121,71 +95,38 @@ export interface ResolvedSummaryGroup {
     hidden: boolean;
     license?: SummaryLicenseConfig;
 }
-/** One column's total, for the footer row. */
 export interface ResolvedColumnTotal {
-    /** The column's `name`. */
     column: string;
-    /** Table-compatible id — `summary.id` or `col_<column>_<type>`. */
     id: string;
     type: SummaryAggregation;
     label: string;
     rawValue: number;
     value: string;
 }
-/**
- * The layout and display half of a table column — the Table's props.
- *
- * On an editable table these sit beside the field definition (`field`, `name`,
- * `fprop`…). Every one is optional: when a column names none of them,
- * `resolveColumnLayout` supplies a default by widget, so an unconfigured column
- * still lays out well. **Prop → default**, the same order as `size` and
- * `keyboard`.
- */
 export interface TableColumnDisplayProps<T = any> {
-    /** Fixed width in px. A column with a width is fixed; one without shares the remaining space. */
     width?: number;
-    /** Floor in px before the table scrolls sideways. Ignored for a fixed column, whose floor is its width. */
     minWidth?: number;
     align?: ColumnAlign;
-    /** Pin while scrolling sideways. A sticky column is always fixed-width, so offsets stay exact. */
     sticky?: ColumnSticky;
-    /** Shorthand for `summary: { type: 'sum' }`. */
     summable?: boolean;
     summary?: ColumnSummaryConfig<T>;
-    /**
-     * Render the value as text instead of a field. For derived values — T.Cost —
-     * that are results, not inputs. Keyboard navigation skips a read-only cell.
-     */
     readOnly?: boolean;
-    /** Custom read-only content. Implies `readOnly`. */
     cell?: (value: any, row: T, index: number) => ReactNode;
     cellStyle?: (value: any, row: T) => CellStyle | undefined;
 }
-/** What `resolveColumnLayout` hands the renderer — every decision made, nothing optional left to guess. */
 export interface ResolvedColumnLayout {
-    /** Present for fixed columns; absent for flexible ones, which share the remainder. */
     width?: number;
     minWidth: number;
     align: ColumnAlign;
     fixed: boolean;
     sticky?: ColumnSticky;
-    /** px from the pinned edge, cumulative across pinned columns on the same side. */
     stickyOffset?: number;
-    /** The innermost pinned column on its side — draws the divider where scrolling content passes under. */
     stickyEdge?: boolean;
-    /**
-     * Flexible columns only: this column's share of the space the fixed columns leave,
-     * in proportion to its floor. Proportional rather than equal on purpose — an equal
-     * split can hand a 300px-floor column less than its floor while a 50px one gets
-     * spare, even though the table as a whole is above its minimum width.
-     */
     flexShare?: number;
 }
 export interface ResolvedTableLayout {
     columns: ResolvedColumnLayout[];
-    /** Σ of every column's floor. The table scrolls sideways only below this. */
     minTableWidth: number;
-    /** Σ of the fixed columns' widths — what a flexible column's share is taken from the rest of. */
     fixedWidthTotal: number;
     hasSticky: boolean;
 }

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

@@ -1,39 +1,18 @@
 import type { ReactElement, ReactNode } from 'react';
 export type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
-/**
- * Where a field's tooltip is triggered from: a help icon beside the label
- * (default — never fires while someone is typing), or the control itself.
- */
 export type TooltipTrigger = 'icon' | 'control';
-/**
- * What a hover tooltip is positioned against.
- *
- * `auto` (default) anchors to the trigger's box, except when that box is wider
- * than the tooltip itself — a full-width line of text, a table row — where
- * centring on the element puts the tip nowhere near the cursor. Those anchor to
- * the pointer instead.
- *
- * Keyboard focus always anchors to the element: there is no cursor involved.
- */
 export type TooltipAnchorTo = 'auto' | 'element' | 'pointer';
 export interface TooltipConfig {
     content: ReactNode;
     placement?: TooltipPlacement;
     anchorTo?: TooltipAnchorTo;
-    /** ms before showing. Default 500 — 0 while another tooltip is still warm. */
     delay?: number;
-    /** ms before hiding. Default 100. */
     closeDelay?: number;
     disabled?: boolean;
     className?: string;
 }
-/**
- * What every `tooltip` prop accepts: bare content for the common case
- * (`tooltip="Delete row"`), or a config object when placement/delay matter.
- */
 export type TooltipProp = ReactNode | TooltipConfig;
 export interface TooltipProps extends TooltipConfig {
-    /** A single element — Tooltip clones it rather than wrapping it in a div. */
     children: ReactElement;
     id?: string;
 }
@@ -44,7 +23,6 @@ export interface TooltipRect {
     height: number;
 }
 export interface TooltipPositionInput {
-    /** Trigger box in viewport coordinates. */
     anchor: TooltipRect;
     tooltip: {
         width: number;
@@ -55,14 +33,11 @@ export interface TooltipPositionInput {
         height: number;
     };
     placement: TooltipPlacement;
-    /** Gap between trigger and tooltip. */
     offset: number;
-    /** Minimum distance kept from the viewport edge. */
     margin?: number;
 }
 export interface TooltipPosition {
     top: number;
     left: number;
-    /** Placement actually used — may differ from the request after flipping. */
     placement: TooltipPlacement;
 }