@dcs-tech/ui 0.2.0 → 0.4.0

package/dist/types/components/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/components/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/components/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/components/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/components/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/components/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/components/DataTable/ui-local/scrollLock.d.ts

@@ -0,0 +1 @@
+export { lockScroll, useScrollLock } from '../../Floating';

package/dist/types/components/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/components/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/components/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/components/DataTable/vendor/columnOrder.d.ts

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

package/dist/types/components/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/components/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/components/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/components/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/components/DatePicker/Calendar.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { CalendarView, IsoDay } from '../../core/logic';
+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/components/DatePicker/DatePicker.d.ts

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

package/dist/types/components/DatePicker/TimeField.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { ControlSize, ControlVariant } from '../../core/types';
+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/components/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 '../../core/types';

package/dist/types/components/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/components/Dialog/Dialog.d.ts

@@ -0,0 +1,56 @@
+import React from 'react';
+export type DialogPlacement = 'center' | 'right' | 'left' | 'top' | 'bottom';
+export type DialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+export interface DialogClassNames {
+    root?: string;
+    panel?: string;
+    header?: string;
+    body?: string;
+    footer?: string;
+    closeButton?: string;
+}
+export interface DialogStyles {
+    root?: React.CSSProperties;
+    panel?: React.CSSProperties;
+    header?: React.CSSProperties;
+    body?: React.CSSProperties;
+    footer?: React.CSSProperties;
+    closeButton?: React.CSSProperties;
+}
+export interface DialogProps {
+    open: boolean;
+    onClose?: () => void;
+    onBeforeClose?: () => boolean;
+    onEscKeyDown?: (event: Event) => void;
+    onOverlayClick?: (event: React.PointerEvent) => void;
+    onAnimationEnd?: () => void;
+    children?: React.ReactNode;
+    title?: React.ReactNode;
+    subtitle?: React.ReactNode;
+    footer?: React.ReactNode;
+    modal?: boolean;
+    placement?: DialogPlacement;
+    size?: DialogSize;
+    closeOnBackdrop?: boolean;
+    closeOnEscape?: boolean;
+    showCloseButton?: boolean;
+    closeIcon?: React.ReactNode;
+    closeIconId?: string;
+    blockScroll?: boolean;
+    reserveScrollBarGap?: boolean;
+    initialFocusRef?: React.RefObject<HTMLElement | null>;
+    container?: Element | null;
+    animationDuration?: number;
+    padded?: boolean;
+    classNames?: DialogClassNames;
+    styleSlots?: DialogStyles;
+    className?: string;
+    style?: React.CSSProperties;
+    role?: string;
+    id?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+}
+declare const Dialog: React.FC<DialogProps>;
+export default Dialog;

package/dist/types/components/Dialog/DialogHost.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import type { ButtonProps } from '../../core/types';
+export type DialogActionProps = Omit<ButtonProps, 'onClick' | 'loading' | 'children'>;
+export interface DialogChoice extends DialogActionProps {
+    value: string;
+    label: NonNullable<ButtonProps['label']>;
+    action?: (...args: any[]) => unknown;
+    args?: unknown[];
+}
+interface BaseOptions {
+    title?: string;
+    message: React.ReactNode;
+    cancelLabel?: string | null;
+    cancelButton?: DialogActionProps;
+}
+export interface ConfirmOptions extends BaseOptions {
+    confirmLabel?: string;
+    tone?: 'primary' | 'danger';
+    confirmButton?: DialogActionProps;
+    action?: (...args: any[]) => unknown;
+    args?: unknown[];
+    focus?: 'confirm' | 'cancel';
+}
+export interface ChooseOptions extends BaseOptions {
+    choices: DialogChoice[];
+    focus?: string;
+}
+export interface AlertOptions {
+    title?: string;
+    message: React.ReactNode;
+    okLabel?: string;
+    tone?: 'primary' | 'danger';
+    okButton?: DialogActionProps;
+}
+export interface DialogApi {
+    confirm: (opts: ConfirmOptions) => Promise<boolean>;
+    choose: (opts: ChooseOptions) => Promise<string | null>;
+    alert: (opts: AlertOptions) => Promise<void>;
+}
+export declare const useDialog: () => DialogApi;
+export declare const DialogHost: React.FC<{
+    children?: React.ReactNode;
+}>;
+export {};

package/dist/types/components/DropdownMenu/DropdownMenu.d.ts

@@ -0,0 +1,49 @@
+import React from 'react';
+import type { PopoverPlacement } from '../../core/logic';
+import type { FloatingAnchor } from '../Popover/floatingPosition';
+export interface DropdownMenuItem {
+    value: string;
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+    hint?: React.ReactNode;
+    disabled?: boolean;
+    danger?: boolean;
+    groupLabel?: string;
+    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 {
+    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;
+    matchTriggerWidth?: boolean;
+    size?: 'xxs' | 'xs' | 'small' | 'medium' | 'large' | 'xl';
+    closeOnSelect?: boolean;
+    'aria-label'?: string;
+    className?: string;
+}
+declare const DropdownMenu: React.FC<DropdownMenuProps>;
+export default DropdownMenu;

package/dist/types/{shared-web-ui/src → components}/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.
- */
+import type { EditableTableMethods, EditableTableProps } from '../../core/types';
 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 → components}/EditableTable/EditableTableActions.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import type { EditableTableActionsProps } from '../../../published/dcs-ui/src/publicTypes';
+import type { EditableTableActionsProps } from '../../core/types';
 declare const _default: React.MemoExoticComponent<(<T extends Record<string, any>>({ currentRowIndex, currentRowData, tableData, totalRows, fixedRows, copyConfig, onAddRow, onCopyRow, onDeleteRow, addIcon, copyIcon, deleteIcon, }: EditableTableActionsProps<T>) => React.JSX.Element)>;
 export default _default;

package/dist/types/{shared-web-ui/src → components}/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.
- */
+import type { ChangeContext, ColumnAlign, EditableTableColumnDefinition, FieldComponentRegistry, FieldTooltipProps, ResolvedColumnLayout } from '../../core/types';
+import type { ResolvedRule } from '../../core/logic';
 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/components/EditableTable/EditableTableRow.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { EditableTableRowProps, ResolvedColumnLayout } from '../../core/types';
+import type { EditableTableCellActions } from '../../core/types';
+import type { ResolvedRule } from '../../core/logic';
+export interface EditableTableRowRenderProps<T> extends EditableTableRowProps<T> {
+    columnLayouts: ResolvedColumnLayout[];
+    getCellRule?: (rowIndex: number, cellindex: number) => ResolvedRule;
+    cellActions?: EditableTableCellActions;
+    rowState?: 'entering' | 'exiting';
+    landedCellIndex?: number | null;
+}
+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/components/EditableTable/EditableTableSummary.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { ResolvedTableSummary } from '../../core/logic';
+import type { EditableTableProps, EditableTableSummaryContext, SummaryLicenseConfig } from '../../core/types';
+interface EditableTableSummaryProps<T> {
+    summary: NonNullable<EditableTableProps<T>['summary']>;
+    resolved: ResolvedTableSummary;
+    context: EditableTableSummaryContext<T>;
+    renderLicense?: (license: SummaryLicenseConfig, children: React.ReactNode) => React.ReactNode;
+}
+declare function EditableTableSummary<T>({ summary, resolved, context, renderLicense }: EditableTableSummaryProps<T>): React.JSX.Element | null;
+export default EditableTableSummary;

package/dist/types/{shared-web-ui/src → components}/EditableTable/index.d.ts

@@ -5,4 +5,4 @@ export { default as EditableTableActions } from './EditableTableActions';
 export { default as EditableTableCell, frameProps, formatReadOnlyValue } from './EditableTableCell';
 export { default as EditableTableSummary } from './EditableTableSummary';
 export { useEditableTable } from './useEditableTable';
-export type { EditableTableProps, EditableTableRowProps, EditableTableActionsProps, EditableTableColumnDefinition, EditableTableFocusState, EditableTableCopyConfig, EditableTableAddConfig, EditableTableDeleteConfig, EditableTableFooterConfig, EditableTableSummaryContext, EditableTableSummaryActions, EditableTableMethods, EditableTableValidity, EditableTableRowValidity, EditableTableRowFailure, EditableTableCellActions, ButtonCellContext, CellRule, TableColumnDisplayProps, TableSummaryConfig, ColumnSummaryConfig, SummaryItem, SummaryGroup, CellStyle, ColumnAlign, ColumnSticky, } from '../../../published/dcs-ui/src/publicTypes';
+export type { EditableTableProps, EditableTableRowProps, EditableTableActionsProps, EditableTableColumnDefinition, EditableTableFocusState, EditableTableCopyConfig, EditableTableAddConfig, EditableTableDeleteConfig, EditableTableFooterConfig, EditableTableSummaryContext, EditableTableSummaryActions, EditableTableMethods, EditableTableValidity, EditableTableRowValidity, EditableTableRowFailure, EditableTableCellActions, ButtonCellContext, CellRule, TableColumnDisplayProps, TableSummaryConfig, ColumnSummaryConfig, SummaryItem, SummaryGroup, CellStyle, ColumnAlign, ColumnSticky, } from '../../core/types';

package/dist/types/{shared-web-ui/src → components}/EditableTable/useEditableTable.d.ts

@@ -1,4 +1,4 @@
-import type { EditableTableProps, FieldHandle } from '../../../published/dcs-ui/src/publicTypes';
+import type { EditableTableProps, FieldHandle } from '../../core/types';
 interface UseEditableTableParams<T> extends EditableTableProps<T> {
     rootTableId: string;
 }
@@ -19,14 +19,14 @@ export declare const useEditableTable: <T extends Record<string, any>>({ columns
     }>;
     focusCellInRow: (rowIndex: number, cellindex?: number) => boolean;
     isCellDisabled: (rowIndex: number, cellindex: number) => boolean;
-    cellRule: (rowIndex: number, cellindex: number) => import("../../../published/dcs-ui/src/publicLogic").ResolvedRule | {
+    cellRule: (rowIndex: number, cellindex: number) => import("../../core/logic").ResolvedRule | {
         readonly valid: true;
         readonly severity: "block";
     };
     rowRules: (rowIndex: number) => {
         valid: boolean;
         blocked: boolean;
-        failures: import("../../../published/dcs-ui/src/publicLogic").RowRuleFailure[];
+        failures: import("../../core/logic").RowRuleFailure[];
     };
     canLeaveCell: (rowIndex: number, cellindex: number) => boolean;
     addNewRow: (insertIndex?: number, isCopy?: boolean) => void;

package/dist/types/components/EditableTable/useRowAnimation.d.ts

@@ -0,0 +1,12 @@
+export declare const ROW_EXIT_MS = 280;
+export interface RowAnimation {
+    rowState: (rowKey: string) => 'entering' | 'exiting' | undefined;
+    landedCell: {
+        rowKey: string;
+        cellindex: number;
+    } | null;
+    removeRow: (rowKey: string | undefined, remove: () => void) => void;
+    noteLanding: (rowKey: string | undefined, cellindex: number) => void;
+    enabled: boolean;
+}
+export declare function useRowAnimation(rowKeys: string[], animate?: boolean): RowAnimation;

package/dist/types/components/FieldContext/FieldContext.d.ts

@@ -0,0 +1,3 @@
+import type { FieldContextValue } from '../../core/types';
+export declare const FieldContext: import("react").Context<FieldContextValue>;
+export declare const useFieldContext: () => FieldContextValue;

package/dist/types/components/FieldContext/FieldProvider.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { FieldProviderProps } from '../../core/types';
+declare const FieldProvider: React.FC<FieldProviderProps>;
+export default FieldProvider;

package/dist/types/{shared-web-ui/src → components}/FieldContext/index.d.ts

@@ -6,4 +6,4 @@ export { useFormKeyboard } from './useFormKeyboard';
 export type { UseFormKeyboardOptions } from './useFormKeyboard';
 export type { UseFieldOptions, UseFieldResult } from './useField';
 export type { FieldSurfaceInput, FieldSurfaceDefaults, ResolvedFieldSurface, ResolvedToggleSurface, } from './useFieldSurface';
-export type { FieldContextValue, FieldProviderProps } from '../../../published/dcs-ui/src/publicTypes';
+export type { FieldContextValue, FieldProviderProps } from '../../core/types';