@dcs-tech/ui 0.2.0 → 0.4.0

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

@@ -0,0 +1,6 @@
+import type { NavItem } from '../types';
+export declare function findNavTrail(items: NavItem[], id: string | null | undefined): NavItem[];
+export declare function flattenNav(items: NavItem[]): NavItem[];
+export declare function filterNav(items: NavItem[], keep: (item: NavItem) => boolean): NavItem[];
+export declare function navTrailIds(items: NavItem[], activeId: string | null | undefined): Set<string>;
+export declare function findNavItemByPath(items: NavItem[], pathname: string): NavItem | null;

package/dist/types/core/logic/popover.logic.d.ts

@@ -0,0 +1,59 @@
+export type PopoverSide = 'top' | 'bottom' | 'left' | 'right';
+export type PopoverAlign = 'start' | 'center' | 'end';
+export type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+export interface PopoverRect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface ComputePopoverPositionInput {
+    anchor: PopoverRect;
+    content: {
+        width: number;
+        height: number;
+    };
+    viewport: {
+        width: number;
+        height: number;
+    };
+    scroll?: {
+        x: number;
+        y: number;
+    };
+    origin?: {
+        x: number;
+        y: number;
+    };
+    placement?: PopoverPlacement;
+    offset?: number;
+    matchAnchorWidth?: boolean;
+    flip?: boolean;
+    shift?: boolean;
+    padding?: number;
+}
+export interface PopoverPosition {
+    top: number;
+    left: number;
+    width?: number;
+    placement: PopoverPlacement;
+    flipped: boolean;
+}
+export declare function computePopoverPosition(input: ComputePopoverPositionInput): PopoverPosition;
+export interface FloatingFrameMeasure {
+    rect: {
+        top: number;
+        left: number;
+    };
+    clientTop: number;
+    clientLeft: number;
+    scrollTop: number;
+    scrollLeft: number;
+}
+export declare function floatingOrigin(frame: FloatingFrameMeasure | null, pageScroll: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};

package/dist/types/core/logic/popupList.logic.d.ts

@@ -0,0 +1,19 @@
+import type { FieldSize, FieldVariant, SelectOption, GroupConfig } from '../types';
+export interface PopupListClassOptions {
+    size: FieldSize;
+    variant: FieldVariant;
+}
+export declare const isJoinedPopupVariant: (variant: string | undefined) => boolean;
+export declare function buildPopupListClassKeys(opts: PopupListClassOptions): string[];
+export interface PopupRowClassOptions {
+    isCursor?: boolean;
+    isSelected?: boolean;
+    isDisabled?: boolean;
+    isMulti?: boolean;
+}
+export declare function buildPopupRowClassKeys(opts: PopupRowClassOptions): string[];
+export interface OptionGroup {
+    name: string;
+    options: SelectOption[];
+}
+export declare function groupSelectOptions(options: SelectOption[], config?: GroupConfig): OptionGroup[];

package/dist/types/core/logic/press.logic.d.ts

@@ -0,0 +1,14 @@
+export interface RippleGeometry {
+    x: number;
+    y: number;
+    size: number;
+}
+export declare function rippleGeometry(box: {
+    width: number;
+    height: number;
+}, point?: {
+    x: number;
+    y: number;
+} | null): RippleGeometry;
+export declare const MIN_PRESS_MS = 150;
+export declare function pressReleaseDelay(heldMs: number, minMs?: number): number;

package/dist/types/core/logic/quickAddGrid.logic.d.ts

@@ -0,0 +1,183 @@
+export type QuickAddAxisMode = 'variant' | 'reference';
+export interface QuickAddAxis {
+    key: string;
+    mode: QuickAddAxisMode;
+}
+export type QuickAddHeaderBehavior = 'none' | 'copy' | 'split' | 'dependentSplit';
+export type QuickAddCellFormula = {
+    op: 'value';
+    key: string;
+} | {
+    op: 'number';
+    value: number;
+} | {
+    op: 'add';
+    args: QuickAddCellFormula[];
+} | {
+    op: 'mul';
+    args: QuickAddCellFormula[];
+};
+export type QuickAddTotalRule = {
+    mode: 'off';
+} | {
+    mode: 'sum';
+    formula?: QuickAddCellFormula;
+};
+export interface QuickAddFieldSpec {
+    key: string;
+    numeric?: boolean;
+    decimalScale?: number;
+    defaultValue?: unknown;
+    isSubmitKey?: boolean;
+    onHeader?: QuickAddHeaderBehavior;
+    dependsOn?: string;
+    totalRule?: QuickAddTotalRule;
+}
+export type QuickAddCombo = Record<string, string>;
+export type QuickAddCell = Record<string, unknown>;
+export type QuickAddCells = Record<string, QuickAddCell>;
+export declare function buildQuickAddSpecs(config: {
+    axes?: string[];
+    refaxes?: string[];
+    fields?: string[];
+    split?: string[];
+    fieldMeta?: Record<string, {
+        decimalScale?: number;
+        isSubmitKey?: boolean;
+        editable?: boolean;
+        totalRule?: QuickAddTotalRule;
+    }>;
+}): {
+    axes: QuickAddAxis[];
+    fields: QuickAddFieldSpec[];
+};
+export declare function comboKey(axes: QuickAddAxis[], combo: QuickAddCombo): string;
+export declare function variantComboKey(axes: QuickAddAxis[], combo: QuickAddCombo): string;
+export declare function buildVariantKeySet(axes: QuickAddAxis[], variants: Array<Record<string, unknown>>): Set<string>;
+export declare function isComboAvailable(combo: QuickAddCombo, params: {
+    axes: QuickAddAxis[];
+    variantKeys: Set<string>;
+    requireVariantMatch?: boolean;
+}): boolean;
+export declare function resolveQuickAddVariant<T extends Record<string, unknown>>(combo: QuickAddCombo, params: {
+    axes: QuickAddAxis[];
+    variants: T[];
+    itemid?: string;
+    itemKey?: string;
+}): T | undefined;
+export declare function quickAddLayout(axes: QuickAddAxis[]): {
+    columnAxis?: QuickAddAxis;
+    rowAxis?: QuickAddAxis;
+    slicerAxes: QuickAddAxis[];
+};
+export declare function axisValues<T extends {
+    value: string;
+}>(params: {
+    axis: QuickAddAxis;
+    options: T[];
+    variants: Array<Record<string, unknown>>;
+    emptyOption: T;
+}): T[];
+export declare function orderValues(picked: string[], order: string[]): string[];
+export declare function planQuickEntry(params: {
+    axes: QuickAddAxis[];
+    picked: Record<string, string | undefined>;
+    variantKeys?: Set<string>;
+    requireVariantMatch?: boolean;
+}): {
+    key: string;
+    missingAxes: string[];
+    available: boolean;
+};
+export declare function selectionFromRows(params: {
+    rows: Array<Record<string, unknown>>;
+    axes: QuickAddAxis[];
+    isEmpty?: (row: Record<string, unknown>) => boolean;
+}): Record<string, string[]>;
+export declare function singleAnswerAxes<T extends {
+    value: string;
+}>(params: {
+    axes: QuickAddAxis[];
+    valuesByAxis: Record<string, T[] | undefined>;
+}): {
+    auto: Record<string, string>;
+    preset: Record<string, string>;
+};
+export declare function dropAxisValue(params: {
+    cells: QuickAddCells;
+    axes: QuickAddAxis[];
+    axisKey: string;
+    value: string;
+}): QuickAddCells;
+export declare function buildCombos(params: {
+    axes: QuickAddAxis[];
+    selected: Record<string, string[]>;
+    variantKeys?: Set<string>;
+    requireVariantMatch?: boolean;
+}): Array<{
+    key: string;
+    combo: QuickAddCombo;
+}>;
+export declare function buildCellDefaults(fields: QuickAddFieldSpec[]): QuickAddCell;
+export declare function clampScale(scale: unknown): number;
+export declare function roundToScale(value: number, scale: number): number;
+export declare function isNumericField(field: QuickAddFieldSpec): boolean;
+export declare function cellNumber(cell: QuickAddCell | undefined, key: string): number;
+export declare function parseHeaderValue(field: QuickAddFieldSpec, raw: unknown): number | string | null;
+export declare function distributeEvenly(totalUnits: number, count: number): number[];
+export declare function distributeByWeights(totalUnits: number, weights: number[]): number[];
+export declare function applyHeaderValue(params: {
+    cells: QuickAddCells;
+    targetKeys: string[];
+    fields: QuickAddFieldSpec[];
+    field: QuickAddFieldSpec;
+    rawValue: unknown;
+}): QuickAddCells;
+export declare function evaluateCellFormula(cell: QuickAddCell | undefined, formula: QuickAddCellFormula): number;
+export declare function scopeTotal(cells: QuickAddCells, keys: string[], field: QuickAddFieldSpec): number;
+export type QuickAddDuplicates = 'first' | 'last' | 'merge';
+export declare function prefillCellsFromRows(params: {
+    rows: Array<Record<string, unknown>>;
+    axes: QuickAddAxis[];
+    fields: QuickAddFieldSpec[];
+    allowedKeys?: Iterable<string>;
+    duplicates?: QuickAddDuplicates;
+    rowKeyMap?: Record<string, string>;
+}): QuickAddCells;
+export declare function buildSubmitCombos(params: {
+    cells: QuickAddCells;
+    axes: QuickAddAxis[];
+    fields: QuickAddFieldSpec[];
+    keys: string[];
+    valueOrder?: Record<string, string[]>;
+}): Array<{
+    key: string;
+    combo: QuickAddCombo;
+    values: Record<string, unknown>;
+}>;
+export type SingleEntryBy = 'item' | 'variant' | 'sku';
+export declare function singleEntryViolations(params: {
+    rows: Array<Record<string, unknown>>;
+    by: SingleEntryBy;
+    itemKey?: string;
+    variantKey?: string;
+    isBlank?: (row: Record<string, unknown>) => boolean;
+}): number[];
+export declare function planRowUpsert(params: {
+    submitted: Array<{
+        combo: QuickAddCombo;
+        values: Record<string, unknown>;
+    }>;
+    rows: Array<Record<string, unknown>>;
+    axes: QuickAddAxis[];
+}): {
+    update: Array<{
+        index: number;
+        values: Record<string, unknown>;
+    }>;
+    create: Array<{
+        combo: QuickAddCombo;
+        values: Record<string, unknown>;
+    }>;
+    remove: number[];
+};

package/dist/types/core/logic/select.logic.d.ts

@@ -0,0 +1,17 @@
+import { SelectOption, SortConfig, SearchConfig } from '../types';
+interface SelectClassOpts {
+    size: string;
+    isOpen?: boolean;
+    disabled?: boolean;
+    error?: boolean;
+    isInModal?: boolean;
+}
+export declare function buildSelectClassKeys(opts: SelectClassOpts): string[];
+export declare function normalizeSelectOptions(options: (string | number | SelectOption)[]): SelectOption[];
+export declare function sortSelectOptions(options: SelectOption[], sortConfig?: boolean | SortConfig): SelectOption[];
+export declare function filterSelectOptions(options: SelectOption[], searchTerm: string, searchConfig?: boolean | SearchConfig): SelectOption[];
+export declare function findTypeaheadIndex(options: Array<{
+    name: string | number;
+    disabled?: boolean;
+}>, query: string, fromIndex: number): number;
+export {};

package/dist/types/core/logic/stepper.logic.d.ts

@@ -0,0 +1,6 @@
+export type StepState = 'done' | 'current' | 'ahead';
+export declare function stepStates(keys: string[], active: string): StepState[];
+export declare function isStepClickable(state: StepState, opts: {
+    hasHandler: boolean;
+    disabled?: boolean;
+}): boolean;

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

@@ -1,4 +1,4 @@
-import { RenderKey } from '../../../published/dcs-ui/src/publicTypes';
+import { RenderKey } from '../types';
 interface SuggestClassOpts {
     size: string;
     isInModal?: boolean;

package/dist/types/core/logic/tableLayout.logic.d.ts

@@ -0,0 +1,13 @@
+import type { ColumnAlign, EditableTableColumnDefinition, ResolvedColumnLayout, ResolvedTableLayout } from '../types';
+export type ColumnWidget = 'suggest' | 'select' | 'number' | 'derivedNumber' | 'date' | 'text' | 'derivedText' | 'toggle' | 'button' | 'other';
+interface ColumnDefault {
+    width?: number;
+    minWidth: number;
+    align: ColumnAlign;
+}
+export declare const COLUMN_LAYOUT_DEFAULTS: Readonly<Record<ColumnWidget, ColumnDefault>>;
+export declare function classifyColumn(column: EditableTableColumnDefinition<any>): ColumnWidget;
+export declare function resolveColumnLayout(column: EditableTableColumnDefinition<any>): ResolvedColumnLayout;
+export declare function resolveTableLayout(columns: EditableTableColumnDefinition<any>[]): ResolvedTableLayout;
+export declare function isReadOnlyColumn(column: EditableTableColumnDefinition<any>): boolean;
+export {};

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

@@ -1,32 +1,13 @@
-import type { ColumnSummaryConfig, EditableTableColumnDefinition, ResolvedColumnTotal, ResolvedSummaryEntry, ResolvedSummaryGroup, SummaryAggregation, SummaryContext, SummaryFormat, TableSummaryConfig } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * Totals and summaries, pure.
- *
- * A port of the client Table's `useTableSummary`
- * (`apps/web/client/src/Utils/CustomElements/Table/summary/useTableSummary.ts`) —
- * the same aggregation, the same `en-IN` formatting, the same id scheme for
- * column totals, the same "a group key the compute omitted is hidden" rule — so a
- * summary configured for a report table computes identically on an editable one.
- * Moved out of the hook because it makes no decision that needs React, and here
- * it can be asserted directly.
- *
- * One deliberate difference: the Table lists column totals among its summary
- * entries. The editable table renders them in a pinned footer row under their
- * columns instead, so they are returned separately — but they are still fed to
- * every item's `compute` as `resolved`, under the Table's ids.
- */
+import type { ColumnSummaryConfig, EditableTableColumnDefinition, ResolvedColumnTotal, ResolvedSummaryEntry, ResolvedSummaryGroup, SummaryAggregation, SummaryContext, SummaryFormat, TableSummaryConfig } from '../types';
 export declare function formatSummaryValue(value: number, format?: SummaryFormat, decimals?: number, prefix?: string, suffix?: string, formatter?: (value: any) => string): string;
 export declare function aggregateValues(values: number[], type: SummaryAggregation): number;
-/** `summable: true` is shorthand for `summary: { type: 'sum' }`; an explicit `summary` wins. */
 export declare function columnSummaryConfig(column: EditableTableColumnDefinition<any>): ColumnSummaryConfig | undefined;
 export declare function computeColumnTotals<T>(columns: EditableTableColumnDefinition<T>[], rows: T[]): ResolvedColumnTotal[];
 export interface ResolvedTableSummary {
     columnTotals: ResolvedColumnTotal[];
-    /** Column totals keyed by column name — what a render-form summary and the footer row read. */
     totalsByColumn: Record<string, number>;
     entries: ResolvedSummaryEntry[];
     groups: ResolvedSummaryGroup[];
-    /** Every resolved value by id — column totals first, then items in order. */
     resolved: Record<string, number | string>;
     hasColumnTotals: boolean;
     hasSummary: boolean;

package/dist/types/core/logic/timeField.logic.d.ts

@@ -0,0 +1,26 @@
+export type TimeOfDay = string;
+export declare const MINUTES_IN_DAY: number;
+export declare function timeToMinutes(time: TimeOfDay): number;
+export declare function minutesToTime(minutes: number): TimeOfDay;
+export declare const isTimeOfDay: (time: unknown) => boolean;
+export declare function to12Hour(hour24: number): {
+    h12: number;
+    meridiem: 'AM' | 'PM';
+};
+export declare function from12Hour(h12: number, meridiem: 'AM' | 'PM'): number;
+export declare function formatTimeText(time: TimeOfDay, hour12?: boolean): string;
+export declare const timePlaceholder: (hour12?: boolean) => string;
+export declare function parseTimeText(text: string, opts?: {
+    within?: TimeOfDay;
+}): TimeOfDay | null;
+export interface TimeColumns {
+    hours: number[];
+    minutes: number[];
+    meridiems: ('AM' | 'PM')[];
+}
+export declare function buildTimeColumns(time: TimeOfDay, opts?: {
+    hour12?: boolean;
+    minuteStep?: number;
+}): TimeColumns;
+export declare function setTimePart(time: TimeOfDay, part: 'hour' | 'minute' | 'meridiem', value: number | 'AM' | 'PM', hour12?: boolean): TimeOfDay;
+export declare function isTimePartActive(time: TimeOfDay, part: 'hour' | 'minute' | 'meridiem', value: number | 'AM' | 'PM', hour12?: boolean): boolean;

package/dist/types/core/logic/tooltip.logic.d.ts

@@ -0,0 +1,11 @@
+import type { TooltipAnchorTo, TooltipConfig, TooltipPlacement, TooltipPosition, TooltipPositionInput, TooltipProp } from '../types';
+export declare function normalizeTooltip(value: TooltipProp | undefined): TooltipConfig | null;
+export interface TooltipAnchorDecision {
+    anchorTo: TooltipAnchorTo;
+    openedBy: 'pointer' | 'focus';
+    anchorWidth: number;
+    tooltipWidth: number;
+}
+export declare function shouldAnchorToPointer(decision: TooltipAnchorDecision): boolean;
+export declare function resolveTooltipPlacementOrder(placement: TooltipPlacement): TooltipPlacement[];
+export declare function computeTooltipPosition(input: TooltipPositionInput): TooltipPosition;

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

@@ -1,4 +1,4 @@
-import type { TypographyVariant, TypographyColor, TypographyAlign, TypographyWeight, TypographyTransform, TypographyDecoration, TypographyComponent, GradientConfig, TruncateConfig } from '../../../published/dcs-ui/src/publicTypes';
+import type { TypographyVariant, TypographyColor, TypographyAlign, TypographyWeight, TypographyTransform, TypographyDecoration, TypographyComponent, GradientConfig, TruncateConfig } from '../types';
 import type { CSSProperties } from 'react';
 export declare function resolveTypographyComponent(variant: TypographyVariant, component?: TypographyComponent): TypographyComponent;
 export declare function buildTypographyClassKeys(opts: {

package/dist/types/core/logic/uiScale.logic.d.ts

@@ -0,0 +1 @@
+export declare function parseUiScale(value: string | null | undefined): number;

package/dist/types/core/logic/useMergeRefs.d.ts

@@ -0,0 +1,2 @@
+import type { Ref, RefCallback } from 'react';
+export declare function useMergeRefs<T>(...refs: (Ref<T> | undefined | null)[]): RefCallback<T>;

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

@@ -2,11 +2,8 @@ import type { DataAttributes } from './common.types';
 import type { ControlSize, SemanticColor } from './control.types';
 import type { TooltipProp, TooltipTrigger } from './tooltip.types';
 import { CSSProperties, ReactNode, MouseEvent, PointerEvent, KeyboardEvent, FocusEvent, ElementType, Ref } from 'react';
-/** Button's own surface treatments — unrelated to the field variants. */
 export type ButtonVariant = 'filled' | 'outlined' | 'text' | 'elevated' | 'tonal';
-/** @see ControlSize — a Button sizes on the same scale as the fields beside it. */
 export type ButtonSize = ControlSize;
-/** Buttons take the full semantic axis, `neutral` included. */
 export type ButtonColor = SemanticColor;
 export type ButtonShape = 'rectangle' | 'rounded' | 'pill' | 'circle' | 'square';
 export type LoadingPosition = 'start' | 'end' | 'center' | 'overlay';
@@ -26,8 +23,6 @@ export interface ButtonProps extends DataAttributes {
     onBlur?: (event: FocusEvent<HTMLElement>) => void;
     onMouseEnter?: (event: MouseEvent<HTMLElement>) => void;
     onMouseLeave?: (event: MouseEvent<HTMLElement>) => void;
-    /** Button has no rest-prop spread, so hover-driven wrappers (Tooltip clones
-        its child) need these declared or they are silently dropped. */
     onPointerEnter?: (event: PointerEvent<HTMLElement>) => void;
     onPointerMove?: (event: PointerEvent<HTMLElement>) => void;
     onPointerLeave?: (event: PointerEvent<HTMLElement>) => void;
@@ -37,13 +32,7 @@ export interface ButtonProps extends DataAttributes {
     startIcon?: ReactNode;
     endIcon?: ReactNode;
     icon?: ReactNode;
-    /** Same contract as every field's `tooltip`: bare content, or a config
-        object when placement/delay matter. Button already routed this through
-        `useTooltip`/`normalizeTooltip` at runtime — the type said `string`. */
     tooltip?: TooltipProp;
-    /** Accepted for uniformity with the fields. A Button is its own trigger, so
-        `icon` and `control` behave alike; the prop exists so a field and a
-        button can be spread from the same props object. */
     tooltipTrigger?: TooltipTrigger;
     disabled?: boolean;
     loading?: boolean;
@@ -63,6 +52,7 @@ export interface ButtonProps extends DataAttributes {
     disableTextTransform?: boolean;
     disableElevation?: boolean;
     ripple?: boolean;
+    feedback?: 'ripple' | 'press' | 'none';
     showFocusRing?: boolean;
     id?: string;
     buttonRef?: Ref<HTMLElement>;

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

@@ -20,10 +20,6 @@ export interface CheckboxProps extends ToggleFieldProps<string | number, HTMLInp
     checked?: boolean;
     indeterminate?: 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;
     checkboxClassName?: string;
     checkedIcon?: ReactNode;

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

@@ -1,11 +1,6 @@
 import type { Ref } from 'react';
 import type { FieldSize, FieldVariant, FieldLayout } from './fieldWrapper.types';
 import type { TextFieldProps } from './field.types';
-/**
- * How a token is spelled. `braces` — `{invoice.number}` — is what ChipInput has always used.
- * `percent` — `%invoice.number%` — is the report engine's spelling, and it allows keys a brace token
- * cannot hold, such as `agg.sum(row.total)`.
- */
 export type ChipTokenSyntax = 'braces' | 'percent';
 export interface ChipKey {
     key: string;
@@ -37,7 +32,6 @@ export interface ParsedSegment {
 }
 export interface ResolveOptions {
     fallback?: string;
-    /** Default `braces`. */
     syntax?: ChipTokenSyntax;
     undefinedBehavior?: 'keep' | 'remove' | 'fallback';
 }
@@ -52,12 +46,9 @@ export interface FormatValidationResult {
 }
 export type ChipInputSize = FieldSize;
 export type ChipInputVariant = FieldVariant;
-/** Was `'vertical' | 'horizontal' | 'inline'` — the same three arrangements
-    every other field calls `'default' | 'horizontal' | 'inline'`. */
 export type ChipInputLayout = FieldLayout;
 export interface ChipInputProps extends TextFieldProps<string, HTMLDivElement> {
     sources: ChipSources;
-    /** How tokens are spelled in `value`. Default `braces`. */
     syntax?: ChipTokenSyntax;
     inputClassName?: string;
     previewData?: Record<string, Record<string, any>>;
@@ -67,7 +58,6 @@ export interface ChipInputProps extends TextFieldProps<string, HTMLDivElement> {
 export interface UseChipSuggestionsOptions {
     sources: ChipSources;
     searchTerm: string;
-    /** Spelling of the tokens suggestions insert. Default `braces`. */
     syntax?: ChipTokenSyntax;
 }
 export interface UseChipSuggestionsReturn {

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

@@ -3,20 +3,11 @@ import type { TooltipProp } from './tooltip.types';
 import type { ControlSize, SemanticColor } from './control.types';
 export type CollapsibleVariant = 'default' | 'bordered' | 'separated' | 'filled' | 'minimal';
 export type CollapsibleSize = ControlSize;
-/** A container tints from the surface end of the axis, not the state end —
-    a "warning" accordion is a badge's job, not the panel's. */
 export type CollapsibleColor = Extract<SemanticColor, 'primary' | 'secondary' | 'neutral'>;
 export type CollapsibleIconPosition = 'start' | 'end';
 export type CollapsibleExpansionMode = 'single' | 'multiple';
-/** How the open/closed state is signalled: a rotating chevron, or + → −. */
 export type CollapsibleDisclosure = 'chevron' | 'plusminus';
-/** Tint applied to an item's leading icon (and its tile, when tiles are on). */
 export type CollapsibleTone = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info' | 'neutral';
-/**
- * Heading level the trigger is wrapped in. The accordion pattern requires the
- * button to sit inside a heading so the panels appear in the document outline —
- * the right level depends on the surrounding page, so it is a prop.
- */
 export type CollapsibleHeadingLevel = 2 | 3 | 4 | 5 | 6;
 export interface CollapsibleAuthorize {
     type: 'r' | 's' | 'b';
@@ -31,13 +22,9 @@ export interface CollapsibleAuthorize {
 export interface CollapsibleItemProps {
     id?: string;
     title: string | ReactNode;
-    /** Leading icon, shown before the title — not the open/close chevron. */
     icon?: ReactNode;
-    /** Tint for that leading icon and its tile. */
     iconTone?: CollapsibleTone;
-    /** Trailing summary on the header row: "12 items", "₹1,25,000". */
     meta?: string | ReactNode;
-    /** Shown on hover/focus of the header trigger. */
     tooltip?: TooltipProp;
     children?: ReactNode;
     Component?: ComponentType<any>;
@@ -70,11 +57,8 @@ export interface CollapsibleProps {
     size?: CollapsibleSize;
     color?: CollapsibleColor;
     iconPosition?: CollapsibleIconPosition;
-    /** Chevron (default) or +/− for the open/close affordance. */
     disclosure?: CollapsibleDisclosure;
-    /** Leading icons sit in a tinted rounded tile. Off = bare glyph. */
     iconTile?: boolean;
-    /** Heading level wrapping each trigger. Default 3. */
     headingLevel?: CollapsibleHeadingLevel;
     disabled?: boolean;
     className?: string;
@@ -82,11 +66,9 @@ export interface CollapsibleProps {
     animated?: boolean;
     animationDuration?: number;
     showDividers?: boolean;
-    /** Expanded headers stick to the top of the scroll container. */
     stickyHeaders?: boolean;
     collapsedIcon?: ReactNode;
     expandedIcon?: ReactNode;
-    /** Arrow/Home/End move focus between headers, per the accordion pattern. */
     keyboardNavigation?: boolean;
     'aria-label'?: string;
     'aria-labelledby'?: string;

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

@@ -0,0 +1,3 @@
+export interface DataAttributes {
+    [dataAttr: `data-${string}`]: unknown;
+}

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

@@ -0,0 +1,36 @@
+import type { ReactNode } from 'react';
+export type ControlSize = 'xxs' | 'xs' | 'small' | 'medium' | 'large' | 'xl';
+export declare const DEFAULT_CONTROL_SIZE: ControlSize;
+export type ControlVariant = 'outlined' | 'filled' | 'standard' | 'underlined' | 'cell';
+export type ToggleVariant = 'outlined' | 'filled' | 'standard' | 'cell';
+export type ControlLayout = 'default' | 'horizontal' | 'inline' | 'cell';
+export type ControlLabelPosition = 'start' | 'end' | 'top' | 'bottom';
+export type SemanticColor = 'primary' | 'secondary' | 'success' | 'error' | 'warning' | 'info' | 'neutral';
+export type FieldColor = Exclude<SemanticColor, 'neutral'>;
+export interface FieldChangeTarget<V = any> {
+    name?: string;
+    value: V;
+    type?: string;
+    checked?: boolean;
+}
+export interface FieldChangeEvent<V = any> {
+    target: FieldChangeTarget<V>;
+}
+export interface FieldContextValue {
+    size?: ControlSize;
+    variant?: ControlVariant;
+    layout?: ControlLayout;
+    disabled?: boolean;
+    readOnly?: boolean;
+    keyboard?: import('./keyboard.types').FieldKeyboardConfig;
+}
+export interface FieldProviderProps extends FieldContextValue {
+    children?: ReactNode;
+}
+export interface FieldCellContext {
+    rowIndex?: number;
+    cellindex?: number;
+    onCellFocus?: (rowIndex: number, cellindex: number) => void;
+    registerCellRef?: (rowIndex: number, cellindex: number, ref: HTMLElement | null) => void;
+    eTableProps?: Record<string, unknown>;
+}