@dcs-tech/ui 0.2.0 → 0.3.0

package/dist/types/shared-web-ui/src/DataTable/ui-local/AutoHeight.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export interface AutoHeightProps {
+    children: React.ReactNode;
+    duration?: number;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const AutoHeight: React.FC<AutoHeightProps>;
+export default AutoHeight;

package/dist/types/shared-web-ui/src/DataTable/ui-local/DateRangePicker.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import './ui-local.css';
+export interface DateRangeState {
+    from: string;
+    to: string;
+    withtime?: boolean;
+}
+export interface DateRangePickerProps {
+    range?: boolean;
+    state: DateRangeState;
+    setState: (updater: DateRangeState | ((prev: DateRangeState) => DateRangeState)) => void;
+    fromLabel?: string;
+    toLabel?: string;
+}
+export declare function DateRangePicker({ range, state, setState, fromLabel, toLabel }: DateRangePickerProps): React.JSX.Element;
+export default DateRangePicker;

package/dist/types/shared-web-ui/src/DataTable/ui-local/DragAndDropList/DragAndDropList.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { type DragAndDropListProps, type DragAndDropItem } from './types';
+import './DragAndDropList.css';
+export default function DragAndDropList<T = DragAndDropItem>({ state, setState, renderKeys, onReorder, renderItem, getItemKey, className, showDragHandle, isItemDraggable, dragHandleProps, emptyMessage, showManualButtons, showSerialNumber, maxHeight, enableScrolling }: DragAndDropListProps<T>): React.JSX.Element;

package/dist/types/shared-web-ui/src/DataTable/ui-local/DragAndDropList/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './DragAndDropList';
+export { default as DragAndDropList } from './DragAndDropList';
+export * from './types';

package/dist/types/shared-web-ui/src/DataTable/ui-local/DragAndDropList/types.d.ts

@@ -0,0 +1,70 @@
+import { type CSSProperties, type ReactNode, type MouseEvent, type TouchEvent, type DragEvent } from 'react';
+export type DragAndDropItem = any;
+export type GetItemKeyFn<T = DragAndDropItem> = (item: T, index: number) => string | number;
+export type IsItemDraggableFn<T = DragAndDropItem> = (item: T, index: number) => boolean;
+export type OnReorderFn<T = DragAndDropItem> = (newItems: T[]) => void;
+export type RenderItemFn<T = DragAndDropItem> = (item: T, index: number, isDragging: boolean, isDragOver: boolean, dragHandle: ReactNode, moveItem: (fromIndex: number, toIndex: number) => void) => ReactNode;
+export interface DragHandleProps {
+    className?: string;
+    style?: CSSProperties;
+    title?: string;
+    'aria-label'?: string;
+    onClick?: (e: MouseEvent<HTMLSpanElement>) => void;
+    onMouseDown?: (e: MouseEvent<HTMLSpanElement>) => void;
+}
+export interface DragAndDropListProps<T = DragAndDropItem> {
+    state: T[];
+    setState?: (items: T[]) => void;
+    renderKeys?: string | string[];
+    onReorder?: OnReorderFn<T>;
+    renderItem?: RenderItemFn<T>;
+    getItemKey?: GetItemKeyFn<T>;
+    className?: string;
+    showDragHandle?: boolean;
+    isItemDraggable?: IsItemDraggableFn<T>;
+    dragHandleProps?: DragHandleProps;
+    emptyMessage?: string;
+    showManualButtons?: boolean;
+    showSerialNumber?: boolean;
+    maxHeight?: string | number;
+    enableScrolling?: boolean;
+}
+export interface DragAndDropState {
+    draggedIndex: number | null;
+    dragOverIndex: number | null;
+    isDragging: boolean;
+    touchStartY: number | null;
+    touchCurrentY: number | null;
+    touchStartX: number | null;
+    isDragReady: boolean;
+    touchStartTime: number | null;
+}
+export type AutoScrollDirection = 'up' | 'down';
+export interface TouchEventData {
+    clientX: number;
+    clientY: number;
+    startY: number;
+    startX: number;
+    startTime: number;
+}
+export interface DragEventHandlers {
+    handleDragStart: (e: DragEvent<HTMLDivElement>, index: number) => void;
+    handleDragEnd: () => void;
+    handleDragOver: (e: DragEvent<HTMLDivElement>) => void;
+    handleDragEnter: (e: DragEvent<HTMLDivElement>, index: number) => void;
+    handleDragLeave: (e: DragEvent<HTMLDivElement>) => void;
+    handleDrop: (e: DragEvent<HTMLDivElement>, dropIndex: number) => void;
+}
+export interface TouchEventHandlers {
+    handleTouchStart: (e: TouchEvent<HTMLDivElement>, index: number) => void;
+    handleTouchMove: (e: TouchEvent<HTMLDivElement>) => void;
+    handleTouchEnd: () => void;
+}
+export interface ItemRenderContext<T = DragAndDropItem> {
+    item: T;
+    index: number;
+    isCurrentDragging: boolean;
+    isCurrentDragOver: boolean;
+    isDraggable: boolean;
+    itemKey: string | number;
+}

package/dist/types/shared-web-ui/src/DataTable/ui-local/ReactModal.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import './ui-local.css';
+export interface ReactModalProps {
+    isopen?: boolean;
+    onClose?: () => void;
+    showCloseIcon?: boolean;
+    closeOnOverlayClick?: boolean;
+    closeOnEsc?: boolean;
+    modelstyleclass?: 'customModal' | 'customModal2' | 'customModal3' | string;
+    modelclass?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    bodyPadding?: boolean;
+    header?: React.ReactNode;
+    subheader?: React.ReactNode;
+    footer?: React.ReactNode;
+    children?: React.ReactNode;
+    'aria-label'?: string;
+}
+export declare function ReactModal({ isopen, onClose, showCloseIcon, closeOnOverlayClick, closeOnEsc, modelstyleclass, modelclass, size, bodyPadding, header, subheader, footer, children, 'aria-label': ariaLabel, }: ReactModalProps): React.ReactPortal | null;
+export default ReactModal;

package/dist/types/shared-web-ui/src/DataTable/ui.d.ts

@@ -0,0 +1,13 @@
+export { Button as SmartButton, ButtonGroup as SmartButtonGroup } from '../Button';
+export { Input as SmartInput } from '../Input';
+export { Select as SmartSelect } from '../Select';
+export { Checkbox as SmartCheckbox } from '../Checkbox';
+export { Switch as SmartSwitch } from '../Switch';
+export { Tabs as SmartTabs } from '../Tabs';
+export { DropdownMenu as SmartDropdownMenu } from '../DropdownMenu';
+export { Dialog as SmartDialog } from '../Dialog';
+export { Badge as SmartBadge } from '../Badge';
+export { ReactModal } from './ui-local/ReactModal';
+export { DragAndDropList } from './ui-local/DragAndDropList';
+export { AutoHeight } from './ui-local/AutoHeight';
+export { DateRangePicker } from './ui-local/DateRangePicker';

package/dist/types/shared-web-ui/src/DataTable/useDataChangeTracker.d.ts

@@ -0,0 +1,11 @@
+import { type DataTableColumn, type DataTableView, type DataTableFlashColor } from './types';
+export interface CellChange {
+    direction: 'up' | 'down' | 'changed';
+    newValue?: any;
+}
+export declare const FLASH_COLOR_MAP: Record<DataTableFlashColor, {
+    bg: string;
+    text: string;
+}>;
+export declare function resolveFlashColor(change: CellChange, column: DataTableColumn, config: DataTableView): DataTableFlashColor;
+export declare function useDataChangeTracker(data: any[], rowKey: string | undefined, columns: DataTableColumn[]): Map<string, Map<string, CellChange>>;

package/dist/types/shared-web-ui/src/DataTable/useTable.d.ts

@@ -0,0 +1,12 @@
+import { type DataTableView, type DataTableColumn, type UseTableReturn, type DataTableInitialState } from './types';
+import { type DataTableLabels } from './labels';
+export declare function rowMatchesSearch<TData>(row: TData, columns: DataTableColumn<TData>[], search: string): boolean;
+export interface UseTableOptions {
+    serverMode?: boolean;
+    rowCount?: number;
+    initialState?: DataTableInitialState;
+    defaultPageSize?: number;
+    labels?: DataTableLabels;
+    customPaging?: boolean;
+}
+export declare function useTable<TData = any>(data: TData[], config: DataTableView<TData>, options?: UseTableOptions): UseTableReturn<TData>;

package/dist/types/shared-web-ui/src/DataTable/vendor/columnOrder.d.ts

@@ -0,0 +1 @@
+export declare function mergeColumnOrder(saved: readonly string[], config: readonly string[]): string[];

package/dist/types/shared-web-ui/src/DataTable/vendor/diff.d.ts

@@ -0,0 +1,5 @@
+export type DeepPartial<T> = T extends readonly unknown[] ? T : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+export declare function extractDifferences<T>(current: T, defaults: T): DeepPartial<T>;
+export declare function applyDifferences<T>(diff: DeepPartial<T>, defaults: T): T;

package/dist/types/shared-web-ui/src/DataTable/vendor/fileActions.d.ts

@@ -0,0 +1,19 @@
+import type { DataTablePdfFonts } from '../types';
+export type FileFormat = 'pdf' | 'xlsx' | 'csv' | 'html' | 'json' | 'xml' | 'png';
+export type FileAction = 'download' | 'print' | 'share' | 'open' | 'preview';
+export declare const EXTENSION_MAP: Record<FileFormat, string>;
+export declare const MIME_MAP: Record<FileFormat, string>;
+export declare function createPdfBlob(docDef: unknown, fontConfig?: DataTablePdfFonts): Promise<Blob>;
+export declare function rawDataToBlob(format: FileFormat, data: any, fontConfig?: DataTablePdfFonts): Promise<Blob>;
+export declare function safeFileBaseName(name: string): string;
+export declare function safeFileName(filename: string): string;
+export declare function downloadBlob(blob: Blob, filename: string): void;
+export declare function shareFile(blob: Blob, filename: string): Promise<boolean>;
+export declare function openPreview(blob: Blob, format: FileFormat, title?: string): {
+    type: "new_tab";
+} | {
+    type: "modal";
+};
+export declare function executeFileAction(data: any, filename: string, format: FileFormat, action: string, title?: string, fontConfig?: DataTablePdfFonts): Promise<void>;
+export declare function getExtension(format: FileFormat): string;
+export declare function getFormatLabel(format: FileFormat): string;

package/dist/types/shared-web-ui/src/DataTable/vendor/index.d.ts

@@ -0,0 +1,3 @@
+export { mergeColumnOrder } from './columnOrder';
+export { extractDifferences, applyDifferences, type DeepPartial } from './diff';
+export { createPdfBlob, rawDataToBlob, downloadBlob, shareFile, openPreview, executeFileAction, getExtension, getFormatLabel, safeFileName, safeFileBaseName, EXTENSION_MAP, MIME_MAP, type FileFormat, type FileAction, } from './fileActions';

package/dist/types/shared-web-ui/src/DataTable/virtual/useVirtualLines.d.ts

@@ -0,0 +1,27 @@
+import { type MutableRefObject, type RefObject } from 'react';
+import type { DataTableVirtualizeConfig } from '../types';
+export interface VirtualOptions {
+    overscan: number;
+    estimate: number;
+    maxHeight?: number | string;
+}
+export interface ScrollApi {
+    scrollToIndex: (index: number) => void;
+}
+export declare const DEFAULT_OVERSCAN = 8;
+export declare const DEFAULT_ROW_ESTIMATE = 44;
+export declare function resolveVirtual(cfg: DataTableVirtualizeConfig | undefined): VirtualOptions | null;
+export interface VirtualWindow {
+    indexes: number[];
+    before: number;
+    after: number;
+    measure: (el: Element | null) => void;
+}
+export declare function useVirtualLines(opts: {
+    options: VirtualOptions | null;
+    count: number;
+    scrollRef: RefObject<HTMLElement | null>;
+    getKey: (index: number) => string;
+    scrollMargin?: number;
+    scrollApi?: MutableRefObject<ScrollApi | null>;
+}): VirtualWindow | null;

package/dist/types/shared-web-ui/src/DatePicker/Calendar.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { CalendarView, IsoDay } from '../../../published/dcs-ui/src/publicLogic';
+export type CalendarOutside = 'all' | 'leading' | 'trailing' | 'none';
+export interface CalendarProps {
+    view: CalendarView;
+    dayId: (day: IsoDay) => string;
+    dayLabel: (day: IsoDay) => string;
+    weekdayNames: string[];
+    label: string;
+    outside?: CalendarOutside;
+    onPick: (day: IsoDay) => void;
+}
+export declare const Calendar: React.FC<CalendarProps>;
+export default Calendar;

package/dist/types/shared-web-ui/src/DatePicker/DatePicker.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { DatePickerProps, FieldHandle } from '../../../published/dcs-ui/src/publicTypes';
+export declare const TYPING_SETTLE_MS = 250;
+declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<FieldHandle>>;
+export default DatePicker;

package/dist/types/shared-web-ui/src/DatePicker/TimeField.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { ControlSize, ControlVariant } from '../../../published/dcs-ui/src/publicTypes';
+export interface TimeFieldProps {
+    id?: string;
+    size?: ControlSize;
+    variant?: ControlVariant;
+    label: string;
+    value: string;
+    onChange: (next: string) => void;
+    hour12?: boolean;
+    minuteStep?: number;
+    disabled?: boolean;
+    fallback?: string;
+}
+export declare const TimeField: React.FC<TimeFieldProps>;
+export default TimeField;

package/dist/types/shared-web-ui/src/DatePicker/index.d.ts

@@ -0,0 +1,4 @@
+export { default as DatePicker } from './DatePicker';
+export { default as Calendar } from './Calendar';
+export type { CalendarProps } from './Calendar';
+export type { DatePickerProps, DatePickerBaseProps, DatePickerSingleProps, DatePickerRangeProps, DateRangeValue, DateDisplayFormat, DateTextOrder, } from '../../../published/dcs-ui/src/publicTypes';

package/dist/types/shared-web-ui/src/DatePicker/useOneMonthPane.d.ts

@@ -0,0 +1,2 @@
+export declare const ONE_MONTH_PANE = "(max-width: 768px)";
+export declare function useOneMonthPane(): boolean;

package/dist/types/shared-web-ui/src/Dialog/Dialog.d.ts

@@ -19,53 +19,28 @@ export interface DialogStyles {
 }
 export interface DialogProps {
     open: boolean;
-    /** Fired for the close button, backdrop, Escape, or a programmatic close. */
     onClose?: () => void;
-    /**
-     * Veto a close by returning false — a dirty-form guard. Runs for EVERY route out,
-     * including Escape and the backdrop, so there is no way around it.
-     */
     onBeforeClose?: () => boolean;
-    /** Fired when Escape is pressed, before the close is decided. */
     onEscKeyDown?: (event: Event) => void;
-    /** Fired when the backdrop is clicked, before the close is decided. */
     onOverlayClick?: (event: React.PointerEvent) => void;
-    /** Fired after the exit animation finishes and the dialog has left the DOM. */
     onAnimationEnd?: () => void;
     children?: React.ReactNode;
     title?: React.ReactNode;
     subtitle?: React.ReactNode;
-    /** Footer band, right-aligned. */
     footer?: React.ReactNode;
-    /**
-     * Blocks the page behind it and dims it. **Default true** — what most people mean by
-     * "a modal". `false` opens a non-blocking panel and, because it uses `show()` rather than
-     * `showModal()`, does not trap focus.
-     */
     modal?: boolean;
-    /** `center` is a dialog; `right` / `left` / `bottom` / `top` are what a "Sheet" is. */
     placement?: DialogPlacement;
     size?: DialogSize;
     closeOnBackdrop?: boolean;
     closeOnEscape?: boolean;
     showCloseButton?: boolean;
-    /** Replace the built-in ✕. */
     closeIcon?: React.ReactNode;
     closeIconId?: string;
-    /** Lock page scroll while open. Default true. */
     blockScroll?: boolean;
-    /**
-     * Pad the body by the scrollbar width when locking, so the page doesn't jump sideways as
-     * the scrollbar disappears. Default true. No-op where scrollbars are overlaid (macOS).
-     */
     reserveScrollBarGap?: boolean;
-    /** Focus this when it opens, instead of the first focusable child. */
     initialFocusRef?: React.RefObject<HTMLElement | null>;
-    /** Where to render. Defaults to `document.body`. */
     container?: Element | null;
-    /** Enter/exit animation length in ms. Default 200. `0` disables. */
     animationDuration?: number;
-    /** Body padding. Off for a full-bleed child — a table, an embedded report. */
     padded?: boolean;
     classNames?: DialogClassNames;
     styleSlots?: DialogStyles;
@@ -77,25 +52,5 @@ export interface DialogProps {
     'aria-labelledby'?: string;
     'aria-describedby'?: string;
 }
-/**
- * A dialog, on the native `<dialog>` element.
- *
- * Why the platform element rather than a div in a portal:
- *
- * - **`showModal()` puts it in the browser's TOP LAYER**, outside the z-index system entirely.
- *   Nothing on the page can cover it — not a `z-index: 9999` loading overlay, which is the
- *   exact failure that once locked this app behind an unreachable confirm.
- * - Focus trapping, `Escape`, an inert background, `::backdrop` and correct stacking of nested
- *   dialogs come from the platform rather than being re-implemented.
- * - No dependency reaches consumers of the published package.
- *
- * The catch is the inverse of the win: because the dialog is in the top layer, a Popover
- * portalled to `<body>` would render BEHIND it. So the dialog publishes itself as the portal
- * container for its own subtree (`UIPortalContext`) — any Select, Suggest or Popover inside
- * renders into the dialog and therefore above it.
- *
- * Padding lives on the bands, not the panel, so a full-bleed child sits flush between a padded
- * header and footer. Same rule as Card.
- */
 declare const Dialog: React.FC<DialogProps>;
 export default Dialog;

package/dist/types/shared-web-ui/src/Dialog/DialogHost.d.ts

@@ -1,43 +1,28 @@
 import React from 'react';
 import type { ButtonProps } from '../../../published/dcs-ui/src/publicTypes';
-/** Everything a Button takes, minus what the host drives itself. */
 export type DialogActionProps = Omit<ButtonProps, 'onClick' | 'loading' | 'children'>;
 export interface DialogChoice extends DialogActionProps {
-    /** What `choose()` resolves to. Also the React key. */
     value: string;
     label: NonNullable<ButtonProps['label']>;
-    /** Run when picked. May be async — the button shows loading until it settles. */
     action?: (...args: any[]) => unknown;
     args?: unknown[];
 }
 interface BaseOptions {
     title?: string;
-    /** Newlines are preserved, so a multi-line message reads as written. */
     message: React.ReactNode;
-    /** Cancel renders LAST. `null` drops it; Escape and the backdrop still cancel. */
     cancelLabel?: string | null;
     cancelButton?: DialogActionProps;
 }
 export interface ConfirmOptions extends BaseOptions {
     confirmLabel?: string;
-    /** `danger` colours the confirm button `error`. */
     tone?: 'primary' | 'danger';
     confirmButton?: DialogActionProps;
     action?: (...args: any[]) => unknown;
     args?: unknown[];
-    /**
-     * Which button holds focus when the dialog opens, so Enter answers it. Default `confirm`;
-     * pass `cancel` for a destructive question. Arrows move between the buttons either way.
-     */
     focus?: 'confirm' | 'cancel';
 }
 export interface ChooseOptions extends BaseOptions {
-    /** Two or more, rendered left-to-right before Cancel. */
     choices: DialogChoice[];
-    /**
-     * The `value` of the choice that holds focus when the dialog opens, or `'cancel'`.
-     * Default: the first choice. Arrows move between the buttons either way.
-     */
     focus?: string;
 }
 export interface AlertOptions {
@@ -48,32 +33,11 @@ export interface AlertOptions {
     okButton?: DialogActionProps;
 }
 export interface DialogApi {
-    /** Yes / no. Resolves `false` on cancel, Escape or backdrop. */
     confirm: (opts: ConfirmOptions) => Promise<boolean>;
-    /** N options. Resolves the chosen `value`, or `null` if dismissed. */
     choose: (opts: ChooseOptions) => Promise<string | null>;
-    /** Acknowledge-only. */
     alert: (opts: AlertOptions) => Promise<void>;
 }
-/**
- * The imperative dialog API.
- *
- * Throws outside a `UIProvider` rather than returning no-ops: an `await confirm()` that
- * silently resolved `false` would look like the user clicking Cancel, and the calling code
- * would quietly do nothing. A dialog needs a host, so this is the one place the provider is
- * genuinely required.
- */
 export declare const useDialog: () => DialogApi;
-/**
- * Rendered once by `UIProvider`. Owns the single dialog instance the imperative API drives.
- *
- * This is the reason the API is worth moving into the library: the previous hook returned a
- * `confirmHost` ELEMENT that every call site had to remember to render, with a warning in its
- * own docstring that returning a component instead remounted the subtree and broke a form
- * mid-edit. Hosting centrally removes the whole class of mistake.
- *
- * Renders through `<Dialog>` rather than beside it, so there is one dialog implementation.
- */
 export declare const DialogHost: React.FC<{
     children?: React.ReactNode;
 }>;

package/dist/types/shared-web-ui/src/DropdownMenu/DropdownMenu.d.ts

@@ -1,49 +1,49 @@
 import React from 'react';
 import type { PopoverPlacement } from '../../../published/dcs-ui/src/publicLogic';
+import type { FloatingAnchor } from '../Popover/floatingPosition';
 export interface DropdownMenuItem {
-    /** Returned by `onSelect`. Also the React key. */
     value: string;
     label: React.ReactNode;
-    /** Secondary line under the label. */
     description?: React.ReactNode;
     icon?: React.ReactNode;
-    /** Trailing hint — a shortcut, a count. */
     hint?: React.ReactNode;
     disabled?: boolean;
-    /** Renders in the destructive colour. */
     danger?: boolean;
-    /** Non-selectable heading above this item. */
     groupLabel?: string;
-    /** Separator line above this item. */
     divider?: boolean;
+    pane?: string;
+}
+export interface DropdownMenuIcon {
+    value: string;
+    label: string;
+    shortLabel?: string;
+    icon: React.ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    pane?: string;
+}
+export interface DropdownMenuPane {
+    id: string;
+    title: React.ReactNode;
+    content: React.ReactNode;
 }
 export interface DropdownMenuProps {
-    /** Element that opens the menu. Cloned to attach the ref, click and ARIA wiring. */
-    trigger: React.ReactElement;
+    trigger?: React.ReactElement;
+    open?: boolean;
+    anchor?: FloatingAnchor | null;
+    onClose?: () => void;
+    header?: React.ReactNode;
+    icons?: DropdownMenuIcon[];
+    panes?: DropdownMenuPane[];
+    present?: 'popover' | 'sheet';
     items: DropdownMenuItem[];
     onSelect?: (value: string, item: DropdownMenuItem) => void;
     placement?: PopoverPlacement;
-    /** Force the menu to the trigger's width. */
     matchTriggerWidth?: boolean;
-    /**
-     * Row density. Drives the shared popup list's `size_*` class, which is what DEFINES
-     * `--popup-row-pad-y` / `--popup-pad-x` / the font steps. Without one the rows render
-     * with no padding at all, because `.row` reads custom properties nothing declared.
-     */
     size?: 'xxs' | 'xs' | 'small' | 'medium' | 'large' | 'xl';
-    /** Keep it open after a selection — for a menu of toggles. Default false. */
     closeOnSelect?: boolean;
     'aria-label'?: string;
     className?: string;
 }
-/**
- * A menu on top of `Popover` — no second positioning implementation, and the rows reuse the
- * same `popupList` module Select and Suggest render, so a menu row and an option row are the
- * same object visually.
- *
- * Keyboard follows the menu pattern rather than the listbox one: arrows move a roving cursor,
- * Home/End jump, Enter or Space activates, Escape closes and returns focus to the trigger.
- * Disabled items are skipped rather than focused-and-ignored.
- */
 declare const DropdownMenu: React.FC<DropdownMenuProps>;
 export default DropdownMenu;

package/dist/types/shared-web-ui/src/EditableTable/EditableTable.d.ts

@@ -1,10 +1,5 @@
 import React from 'react';
 import type { EditableTableMethods, EditableTableProps } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * `forwardRef` around a GENERIC component loses the generic, so the cast puts it back —
- * the same two lines `Form` uses, deliberately, since these two are the halves of one
- * entry screen and should be reached the same way.
- */
 declare const EditableTable: <T extends Record<string, any>>(props: EditableTableProps<T> & {
     ref?: React.Ref<EditableTableMethods<T>>;
 }) => React.ReactElement | null;

package/dist/types/shared-web-ui/src/EditableTable/EditableTableCell.d.ts

@@ -1,33 +1,15 @@
 import React from 'react';
 import type { ChangeContext, ColumnAlign, EditableTableColumnDefinition, FieldComponentRegistry, FieldTooltipProps, ResolvedColumnLayout } from '../../../published/dcs-ui/src/publicTypes';
 import type { ResolvedRule } from '../../../published/dcs-ui/src/publicLogic';
-/**
- * The frame attributes a column's cells share — header, body and totals alike.
- *
- * Alignment travels as CSS variables rather than a prop on every field: the field's
- * text reads `--cell-text-align`, a toggle's container reads `--cell-justify`, and
- * neither needs to know which column it is in.
- */
 export declare function frameProps(layout: ResolvedColumnLayout): {
     'data-align': ColumnAlign;
     'data-sticky'?: 'left' | 'right';
     'data-sticky-edge'?: '';
     style: React.CSSProperties;
 };
-/**
- * A derived value's default display. Numbers group `en-IN` exactly as the Table's
- * totals do, so a T.Cost cell and the T.Cost total below it read the same way; a
- * blank row still being typed shows nothing rather than `0` or `NaN`.
- */
 export declare function formatReadOnlyValue(value: unknown): string;
 export interface EditableTableCellProps<T> {
-    /**
-     * This cell's resolved rules. A failure becomes the field's `error`, which the cell
-     * layout already draws as a red inset edge with the message in the control's tooltip —
-     * no extra row, so nothing below shifts while someone is typing.
-     */
     rule?: ResolvedRule;
-    /** Focus landed here after a row was added or removed — flash it once. */
     landed?: boolean;
     column: EditableTableColumnDefinition<T>;
     layout: ResolvedColumnLayout;

package/dist/types/shared-web-ui/src/EditableTable/EditableTableRow.d.ts

@@ -3,23 +3,12 @@ import type { EditableTableRowProps, ResolvedColumnLayout } from '../../../publi
 import type { EditableTableCellActions } from '../../../published/dcs-ui/src/publicTypes';
 import type { ResolvedRule } from '../../../published/dcs-ui/src/publicLogic';
 export interface EditableTableRowRenderProps<T> extends EditableTableRowProps<T> {
-    /** One resolved frame per column, from `resolveTableLayout`. */
     columnLayouts: ResolvedColumnLayout[];
-    /** Per-cell validation, resolved by the table (pure `resolveColumnRules` underneath). */
     getCellRule?: (rowIndex: number, cellindex: number) => ResolvedRule;
-    /** The table's row operations, for cells that ACT — a button column's `onClick`. */
     cellActions?: EditableTableCellActions;
-    /** `'entering'` | `'exiting'` while this row is animating — see `useRowAnimation`. */
     rowState?: 'entering' | 'exiting';
-    /** The column focus landed on after a row operation, flashed once so it can be seen. */
     landedCellIndex?: number | null;
 }
-/**
- * A row is just its cells. It used to hand the whole column list to `Fields`, which
- * wrapped each field in a bare `<td>` it had no way to size, align or pin — so the
- * row could not own its frame. Each column now renders through `EditableTableCell`,
- * which does.
- */
 declare const EditableTableRow: <T extends Record<string, any>>({ defaultData, rowIndex, rowData, columnFields, columnLayouts, getCellRule, cellActions, rowState, landedCellIndex, editableTableData, onChange, onKeyDown, onSelect, onCellFocus, registerCellRef, focusedRowIndex, isFocusedRow, focusedCellIndex, tableDataKey, renderAuthorize, renderTooltip, componentRegistry, }: EditableTableRowRenderProps<T>) => React.JSX.Element;
 declare const _default: typeof EditableTableRow;
 export default _default;

package/dist/types/shared-web-ui/src/EditableTable/EditableTableSummary.d.ts

@@ -1,17 +1,6 @@
 import React from 'react';
 import type { ResolvedTableSummary } from '../../../published/dcs-ui/src/publicLogic';
 import type { EditableTableProps, EditableTableSummaryContext, SummaryLicenseConfig } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * The area under the table (D4) — everything that is not a column total.
- *
- * Two forms, one prop:
- * - **config** — the client Table's `TableSummaryConfig`, unchanged, resolved by the
- *   same pure logic, so a summary written for a report table renders here as-is;
- * - **render function** — handed the rows, the resolved column totals and the row
- *   actions, for custom figures and action buttons the table knows nothing about.
- *
- * Rendered below the scroll container, so it is always visible without sticking.
- */
 interface EditableTableSummaryProps<T> {
     summary: NonNullable<EditableTableProps<T>['summary']>;
     resolved: ResolvedTableSummary;