@dcs-tech/ui 0.2.0 → 0.4.0

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

@@ -1,5 +1,5 @@
 export { default as Suggest } from './Suggest';
 export { SuggestionList } from './SuggestionList';
 export { useSuggest } from './useSuggest';
-export type { SuggestProps, SuggestSize, SuggestLayout, SuggestSearchEngine, SuggestSearchMode, RenderKey, SuggestionConfig, SuggestionItemProps, SuggestionListProps, SuggestionGroup, UseSuggestOptions, UseSuggestReturn, SuggestSearchOptions, } from '../../../published/dcs-ui/src/publicTypes';
-export { FORMATTER_UTILITY_CLASSES, SUGGEST_SEARCH_ENGINE_OPTIONS, SUGGEST_SEARCH_MODE_OPTIONS, } from '../../../published/dcs-ui/src/publicTypes';
+export type { SuggestProps, SuggestSize, SuggestLayout, SuggestSearchEngine, SuggestSearchMode, RenderKey, SuggestionConfig, SuggestionItemProps, SuggestionListProps, SuggestionGroup, UseSuggestOptions, UseSuggestReturn, SuggestSearchOptions, } from '../../core/types';
+export { FORMATTER_UTILITY_CLASSES, SUGGEST_SEARCH_ENGINE_OPTIONS, SUGGEST_SEARCH_MODE_OPTIONS, } from '../../core/types';

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

@@ -1,4 +1,4 @@
-import { SuggestSearchOptions } from '../../../published/dcs-ui/src/publicTypes';
+import { SuggestSearchOptions } from '../../core/types';
 export interface MatchSorterSearchOptions {
     data: any[];
     searchTerm: string;

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

@@ -1,2 +1,2 @@
-import { UseSuggestOptions, UseSuggestReturn } from '../../../published/dcs-ui/src/publicTypes';
+import { UseSuggestOptions, UseSuggestReturn } from '../../core/types';
 export declare const useSuggest: ({ data, config, value, minSearchLength, debounceMs, onSelect, selectFirstOnEnter, showAllOnFocus, disabled, }: UseSuggestOptions) => UseSuggestReturn;

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

@@ -1,4 +1,4 @@
 import React from 'react';
-import { SwitchProps, FieldHandle } from '../../../published/dcs-ui/src/publicTypes';
+import { SwitchProps, FieldHandle } from '../../core/types';
 declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<FieldHandle>>;
 export default Switch;

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

@@ -1,2 +1,2 @@
 export { default as Switch } from './Switch';
-export type { SwitchProps, SwitchSize, SwitchLabelPosition, SwitchColor, } from '../../../published/dcs-ui/src/publicTypes';
+export type { SwitchProps, SwitchSize, SwitchLabelPosition, SwitchColor, } from '../../core/types';

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

@@ -0,0 +1,36 @@
+import React from 'react';
+export type TabsVariant = 'line' | 'pill' | 'enclosed';
+export type TabsSize = 'small' | 'medium';
+export interface TabItem {
+    value: string;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    badge?: React.ReactNode;
+    disabled?: boolean;
+    href?: string;
+    props?: Record<string, unknown>;
+}
+export interface TabsProps {
+    items: TabItem[];
+    value?: string;
+    onChange?: (value: string, item: TabItem) => void;
+    as?: React.ElementType;
+    variant?: TabsVariant;
+    size?: TabsSize;
+    fullWidth?: boolean;
+    activateOnFocus?: boolean;
+    idPrefix?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    'aria-label'?: string;
+}
+declare const Tabs: React.FC<TabsProps>;
+export interface TabPanelProps {
+    value: string;
+    idPrefix: string;
+    active: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+export declare const TabPanel: React.FC<TabPanelProps>;
+export default Tabs;

package/dist/types/components/Toast/ToastHost.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { ToastApi, ToastDefaults } from './toast.types';
+export declare const useToast: () => ToastApi;
+export interface ToastHostProps {
+    defaults?: ToastDefaults;
+    children?: React.ReactNode;
+}
+export declare const ToastHost: React.FC<ToastHostProps>;

package/dist/types/components/Toast/ToastItem.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ToastRecord } from './toast.types';
+interface ToastItemProps {
+    toast: ToastRecord;
+    windowFocused: boolean;
+    onDismiss: (id: string) => void;
+    exitDuration: number;
+}
+declare const ToastItem: React.FC<ToastItemProps>;
+export default ToastItem;

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

@@ -3,22 +3,15 @@ export type ToastType = 'default' | 'success' | 'error' | 'warning' | 'info';
 export type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
 export interface ToastOptions {
     type?: ToastType;
-    /** ms, or `false` to stay until dismissed. Default 5000. */
     autoClose?: number | false;
     position?: ToastPosition;
     hideProgressBar?: boolean;
-    /** Click anywhere on the toast to dismiss. Default true. */
     closeOnClick?: boolean;
     pauseOnHover?: boolean;
-    /** Pause the timer while the window is in the background. Default true. */
     pauseOnFocusLoss?: boolean;
-    /** Swipe sideways to dismiss. Default true. */
     draggable?: boolean;
-    /** `false` hides it; a node replaces the default ✕. */
     closeButton?: boolean | React.ReactNode;
-    /** `false` hides it; a node replaces the per-type glyph. */
     icon?: React.ReactNode | false;
-    /** Supply to update or dedupe an existing toast instead of stacking a new one. */
     id?: string;
     onClose?: () => void;
     className?: string;
@@ -28,23 +21,17 @@ export interface ToastRecord extends ToastOptions {
     id: string;
     message: React.ReactNode;
 }
-/** Defaults for every toast, set once on `UIProvider`. */
 export interface ToastDefaults extends Omit<ToastOptions, 'id' | 'onClose'> {
-    /** Most recent first. Default false, matching the client's existing container. */
     newestOnTop?: boolean;
-    /** Max visible at once; the rest queue. Default 4. */
     limit?: number;
 }
 export interface ToastApi {
-    /** Returns the id, so it can be updated or dismissed later. */
     toast: (message: React.ReactNode, opts?: ToastOptions) => string;
     success: (message: React.ReactNode, opts?: ToastOptions) => string;
     error: (message: React.ReactNode, opts?: ToastOptions) => string;
     warning: (message: React.ReactNode, opts?: ToastOptions) => string;
     info: (message: React.ReactNode, opts?: ToastOptions) => string;
-    /** Change a live toast in place — a pending toast becoming success or error. */
     update: (id: string, message: React.ReactNode, opts?: ToastOptions) => void;
-    /** One id, or all of them when omitted. */
     dismiss: (id?: string) => void;
     isActive: (id: string) => boolean;
 }

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { TooltipProp, TooltipProps } from '../../core/types';
+export declare const Tooltip: React.FC<TooltipProps>;
+export interface TooltipHelpIconProps {
+    tooltip: TooltipProp;
+    label?: string;
+}
+export declare const TooltipHelpIcon: React.FC<TooltipHelpIconProps>;
+export default Tooltip;

package/dist/types/components/Tooltip/useTooltip.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { TooltipProp } from '../../core/types';
+export interface UseTooltipResult {
+    triggerProps: {
+        onPointerEnter: (event: React.PointerEvent<HTMLElement>) => void;
+        onPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
+        onPointerLeave: () => void;
+        onFocus: (event: React.FocusEvent<HTMLElement>) => void;
+        onBlur: () => void;
+        'aria-describedby'?: string;
+    };
+    tooltipNode: React.ReactNode;
+    hasTooltip: boolean;
+}
+export declare function useTooltip(tooltip: TooltipProp | undefined): UseTooltipResult;

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

@@ -1,4 +1,4 @@
 import React from 'react';
-import type { TypographyProps } from '../../../published/dcs-ui/src/publicTypes';
+import type { TypographyProps } from '../../core/types';
 declare const Typography: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLElement>>;
 export default Typography;

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

@@ -1,2 +1,2 @@
 export { default as Typography } from './Typography';
-export type { TypographyProps, TypographyVariant, TypographyColor, TypographyAlign, TypographyWeight, TypographyTransform, TypographyDecoration, TypographyComponent, TruncateConfig, GradientConfig, } from '../../../published/dcs-ui/src/publicTypes';
+export type { TypographyProps, TypographyVariant, TypographyColor, TypographyAlign, TypographyWeight, TypographyTransform, TypographyDecoration, TypographyComponent, TruncateConfig, GradientConfig, } from '../../core/types';

package/dist/types/components/UIProvider/UIPortalContext.d.ts

@@ -0,0 +1,2 @@
+export declare const UIPortalContext: import("react").Context<HTMLElement | null>;
+export declare const useUIPortalContainer: () => HTMLElement | null;

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

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { FieldProviderProps } from '../../core/types';
+import type { ToastDefaults } from '../Toast/toast.types';
+import { type ResolvedUITheme, type UITheme } from './UIThemeContext';
+export interface UIProviderProps extends Pick<FieldProviderProps, 'size' | 'variant' | 'layout'> {
+    children?: React.ReactNode;
+    theme?: UITheme;
+    onThemeChange?: (resolved: ResolvedUITheme, requested: UITheme) => void;
+    portalContainer?: HTMLElement | false;
+    toast?: ToastDefaults;
+}
+declare const UIProvider: React.FC<UIProviderProps>;
+export default UIProvider;

package/dist/types/components/UIProvider/UIThemeContext.d.ts

@@ -0,0 +1,9 @@
+export type UITheme = 'light' | 'dark' | 'system';
+export type ResolvedUITheme = 'light' | 'dark';
+export interface UIThemeValue {
+    theme: UITheme;
+    resolvedTheme: ResolvedUITheme;
+    setTheme: (theme: UITheme) => void;
+}
+export declare const UIThemeContext: import("react").Context<UIThemeValue | null>;
+export declare const useUITheme: () => UIThemeValue;

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

@@ -0,0 +1,3 @@
+export { useDebounced, useDebouncedCallback } from './useDebounced';
+export type { DebouncedCallback } from './useDebounced';
+export { usePresence, SURFACE_EXIT_MS } from './usePresence';

package/dist/types/core/hooks/useDebounced.d.ts

@@ -0,0 +1,7 @@
+export declare function useDebounced<T>(value: T, ms: number): T;
+export interface DebouncedCallback<A extends unknown[]> {
+    (...args: A): void;
+    now: () => void;
+    cancel: () => void;
+}
+export declare function useDebouncedCallback<A extends unknown[]>(fn: (...args: A) => void, ms: number): DebouncedCallback<A>;

package/dist/types/core/hooks/usePresence.d.ts

@@ -0,0 +1,5 @@
+export declare const SURFACE_EXIT_MS = 100;
+export declare function usePresence(open: boolean, exitMs?: number): {
+    present: boolean;
+    exiting: boolean;
+};

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

@@ -1,4 +1,4 @@
-import type { ButtonVariant, ButtonSize, ButtonColor, ButtonShape, LoadingPosition, GroupOrientation } from '../../../published/dcs-ui/src/publicTypes';
+import type { ButtonVariant, ButtonSize, ButtonColor, ButtonShape, LoadingPosition, GroupOrientation } from '../types';
 export declare function buildButtonClassKeys(opts: {
     variant: ButtonVariant;
     size: ButtonSize;

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

@@ -0,0 +1,32 @@
+import type { CellRule, ConditionContext, EditableTableColumnDefinition } from '../types';
+export interface ResolvedRule {
+    valid: boolean;
+    message?: string;
+    severity: 'block' | 'warn';
+}
+export declare function resolveCellRules<T>(rules: Array<CellRule<T>> | undefined, rowData: T, defaultData: T, context?: ConditionContext): ResolvedRule;
+export declare function resolveColumnRules<T>(column: EditableTableColumnDefinition<T> | undefined, rowData: T, defaultData: T, rowIndex: number, cellindex: number, tableDataKey?: string): ResolvedRule;
+export interface RowRuleFailure {
+    cellindex: number;
+    message: string;
+    severity: 'block' | 'warn';
+}
+export declare function resolveRowRules<T>(columns: Array<EditableTableColumnDefinition<T>>, rowData: T, defaultData: T, rowIndex: number, tableDataKey?: string): {
+    valid: boolean;
+    blocked: boolean;
+    failures: RowRuleFailure[];
+};
+export declare function isRowBlank<T extends Record<string, any>>(row: T | undefined, defaultData: T, rowKey?: string): boolean;
+export interface CreateRowPolicy {
+    fixedRows?: boolean;
+    allowWhenBlankRow?: boolean;
+    allowWhenInvalid?: boolean;
+}
+export interface CreateRowDecision {
+    allowed: boolean;
+    reason?: 'fixedRows' | 'blankRow' | 'invalidRow' | 'consumer';
+    focusRowIndex?: number;
+}
+export declare function canCreateRow<T extends Record<string, any>>(rows: T[], defaultData: T, policy: CreateRowPolicy, rowRules?: (rowIndex: number) => {
+    blocked: boolean;
+}, rowKey?: string): CreateRowDecision;

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

@@ -1,18 +1,6 @@
-/**
- * ChipInput Logic — Pure functions for format string manipulation and suggestion filtering.
- * No React, no DOM.
- */
-import type { ChipTokenSyntax, ChipSources, ChipSuggestionItem, GroupedSuggestions, ParsedSegment, ResolveOptions, ExtractedPlaceholder, FormatValidationResult } from '../../../published/dcs-ui/src/publicTypes';
-/** The text of one token in the given syntax. */
+import type { ChipTokenSyntax, ChipSources, ChipSuggestionItem, GroupedSuggestions, ParsedSegment, ResolveOptions, ExtractedPlaceholder, FormatValidationResult } from '../types';
 export declare function formatChipToken(source: string, key: string, syntax?: ChipTokenSyntax): string;
-/** The character that starts a token, and so opens the suggestions while typing. */
 export declare function chipTokenOpener(syntax?: ChipTokenSyntax): string;
-/**
- * Whether the text typed since the last opener is still an unfinished token.
- *
- * Percent also stops at whitespace: `%` doubles as ordinary punctuation ("5% off"), and a
- * suggestion list that opened on every percent sign would follow the author around.
- */
 export declare function isOpenChipToken(afterOpener: string, syntax?: ChipTokenSyntax): boolean;
 export declare function parseFormat(format: string, syntax?: ChipTokenSyntax): ParsedSegment[];
 export declare function resolveFormat(format: string, data: Record<string, Record<string, any>>, options?: ResolveOptions): string;

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

@@ -1,4 +1,4 @@
-import { CollapsibleVariant, CollapsibleSize, CollapsibleColor, CollapsibleIconPosition, CollapsibleDisclosure, CollapsibleTone } from '../../../published/dcs-ui/src/publicTypes';
+import { CollapsibleVariant, CollapsibleSize, CollapsibleColor, CollapsibleIconPosition, CollapsibleDisclosure, CollapsibleTone } from '../types';
 interface CollapsibleContainerOpts {
     variant: CollapsibleVariant;
     size: CollapsibleSize;
@@ -24,12 +24,5 @@ interface CollapsibleHeaderOpts {
     isDisabled: boolean;
 }
 export declare function buildCollapsibleHeaderClassKeys(opts: CollapsibleHeaderOpts): string[];
-/**
- * Given the triggers in one accordion and the one holding focus, returns the
- * index to move to. ArrowDown/Up wrap; Home/End jump to the ends. Returns null
- * for any other key, so the caller leaves the event alone.
- *
- * Pure index maths — the DOM query and the .focus() call stay in the component.
- */
 export declare function resolveCollapsibleFocusIndex(key: string, currentIndex: number, total: number): number | null;
 export {};

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

@@ -1,29 +1,15 @@
 export type ColorSchemeMode = 'light' | 'dark';
 export type ColorSchemeRole = 'title' | 'bg' | 'onBg';
 export interface ColorScheme {
-    /** the stored value */
     id: string;
-    /** shown in the picker */
     name: string;
-    /** hue, 0-359 */
     h: number;
-    /** saturation % in light mode */
     s: number;
-    /** saturation % in dark mode — tuned per hue, not a constant (see BUSINESS_COLOR_SCHEMES) */
     sd: number;
 }
 export type ColorSchemeTokens = Record<ColorSchemeRole, string>;
-/** Lightness per role per mode. The only numbers in the system. */
 export declare const COLOR_SCHEME_LIGHTNESS: Record<ColorSchemeMode, Record<ColorSchemeRole, number>>;
-/** One role, as an `hsl()` string. */
 export declare const schemeColor: (scheme: ColorScheme, role: ColorSchemeRole, mode?: ColorSchemeMode) => string;
-/** All three roles for one mode. Use for PDFs and anywhere CSS variables aren't available. */
 export declare const schemeTokens: (scheme: ColorScheme, mode?: ColorSchemeMode) => ColorSchemeTokens;
-/**
- * The custom properties to put on a wrapper element. Only hue and the two saturations —
- * the stylesheet owns the lightness per mode, so the theme switch stays in CSS where it
- * belongs rather than being recomputed in JS on every theme change.
- */
 export declare const schemeVars: (scheme: ColorScheme | null | undefined) => Record<string, string>;
-/** Look one up by stored id. Returns null for '' / unknown, which means "no scheme set". */
 export declare const findColorScheme: (schemes: ColorScheme[], id: string | null | undefined) => ColorScheme | null;

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

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

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

@@ -0,0 +1,136 @@
+import type { DateDisplayFormat, DateTextOrder } from '../types';
+export type IsoDay = string;
+export type DateValue = string;
+export interface DateParts {
+    y: number;
+    m: number;
+    d: number;
+}
+export declare const MIN_DATE_YEAR = 1900;
+export declare const daysInMonth: (y: number, m: number) => number;
+export declare function isRealDay({ y, m, d }: DateParts): boolean;
+export declare const toIsoDay: ({ y, m, d }: DateParts) => IsoDay;
+export declare function parseIsoDay(value: unknown): DateParts | null;
+export declare const isIsoDay: (value: unknown) => boolean;
+export declare const todayIso: (now?: Date) => IsoDay;
+export declare const compareDays: (a: IsoDay, b: IsoDay) => number;
+export declare const isSameDay: (a: unknown, b: unknown) => boolean;
+export declare function shiftDays(day: IsoDay, n: number): IsoDay;
+export declare function shiftMonths(day: IsoDay, n: number): IsoDay;
+export declare const shiftYears: (day: IsoDay, n: number) => IsoDay;
+export declare function startOfMonth(day: IsoDay): IsoDay;
+export declare function endOfMonth(day: IsoDay): IsoDay;
+export declare function weekdayOf(day: IsoDay): number;
+export declare const isDayInRange: (day: IsoDay, min?: string, max?: string) => boolean;
+export declare function clampDay(day: IsoDay, min?: string, max?: string): IsoDay;
+export declare function normalizeTime(value: unknown): string;
+export declare function splitDateValue(value: unknown): {
+    day: IsoDay;
+    time: string;
+};
+export declare function joinDateValue(day: IsoDay, time?: string): DateValue;
+export declare function parseDateText(text: unknown, opts?: {
+    within?: IsoDay;
+    today?: IsoDay;
+    order?: DateTextOrder;
+}): IsoDay | null;
+export declare const RANGE_ADVANCE_KEY = "+";
+export interface TypedDateRange {
+    from: IsoDay;
+    to: IsoDay;
+}
+export declare function parseDateRangeText(text: unknown, opts?: {
+    within?: IsoDay;
+    today?: IsoDay;
+    order?: DateTextOrder;
+}): TypedDateRange | null;
+export declare function formatDayText(day: unknown, format?: DateDisplayFormat): string;
+export declare const datePlaceholder: (format?: DateDisplayFormat, withTime?: boolean) => string;
+export declare function formatDateValueText(value: unknown, format?: DateDisplayFormat, withTime?: boolean): string;
+export declare function parseDateValueText(text: unknown, opts?: {
+    within?: IsoDay;
+    today?: IsoDay;
+    order?: DateTextOrder;
+    withTime?: boolean;
+}): {
+    day: IsoDay;
+    time: string;
+} | null;
+export interface CalendarDay {
+    day: IsoDay;
+    date: number;
+    inMonth: boolean;
+    isToday: boolean;
+    isSelected: boolean;
+    isHighlighted: boolean;
+    inRange: boolean;
+    isRangeStart: boolean;
+    isRangeEnd: boolean;
+    disabled: boolean;
+}
+export interface CalendarView {
+    month: IsoDay;
+    year: number;
+    monthIndex: number;
+    weeks: CalendarDay[][];
+    weekdays: number[];
+    canPagePrev: boolean;
+    canPageNext: boolean;
+}
+export interface CalendarOptions {
+    month: IsoDay;
+    today?: IsoDay;
+    selected?: string | null;
+    highlighted?: string | null;
+    rangeFrom?: string | null;
+    rangeTo?: string | null;
+    min?: string;
+    max?: string;
+    weekStart?: number;
+    fixedWeeks?: boolean;
+}
+export declare function buildCalendar(opts: CalendarOptions): CalendarView;
+export type DateHighlightAction = 'highlightLeft' | 'highlightRight' | 'highlightPrev' | 'highlightNext' | 'highlightFirst' | 'highlightLast' | 'highlightPrevPage' | 'highlightNextPage';
+export declare const DATE_HIGHLIGHT_ACTIONS: readonly DateHighlightAction[];
+export declare function moveHighlight(from: IsoDay, action: DateHighlightAction, opts?: {
+    min?: string;
+    max?: string;
+}): IsoDay;
+export declare function openingHighlight(value?: string | null, opts?: {
+    today?: IsoDay;
+    min?: string;
+    max?: string;
+}): IsoDay;
+export interface DatePreset {
+    key: string;
+    label: string;
+    single?: boolean;
+    from: IsoDay;
+    to: IsoDay;
+}
+export interface DatePresetOptions {
+    today?: IsoDay;
+    fyStartMonth?: number;
+    weekStart?: number;
+    only?: string[];
+}
+export declare function financialYearOf(day: IsoDay, fyStartMonth?: number): {
+    from: IsoDay;
+    to: IsoDay;
+};
+export declare function startOfWeek(day: IsoDay, weekStart?: number): IsoDay;
+export declare function quarterOf(day: IsoDay, fyStartMonth?: number): {
+    from: IsoDay;
+    to: IsoDay;
+};
+export declare function buildDatePresets(opts?: DatePresetOptions): DatePreset[];
+export declare function matchDatePresets(presets: DatePreset[], query: unknown): DatePreset[];
+export interface DayRange {
+    from: IsoDay;
+    to: IsoDay;
+}
+export declare function viewForRange(from: IsoDay, to: IsoDay, opts?: {
+    months?: number;
+    currentMonthSide?: 'left' | 'right';
+}): IsoDay;
+export declare function extendDateRange(range: Partial<DayRange> | null | undefined, day: IsoDay): DayRange;

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

@@ -0,0 +1,4 @@
+export declare function displayOrderOf(entry: unknown): number;
+export declare function sortByDisplayOrder<T extends {
+    value: string;
+}>(options: T[], master: Record<string, unknown> | undefined): T[];

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

@@ -1,43 +1,20 @@
-/**
- * EditableTable Logic — Pure functions for editable table state management.
- * No React, no DOM.
- */
-import type { EditableTableColumnDefinition } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * Get table rows from state, handling nested paths via tableDataKey.
- */
+import type { EditableTableColumnDefinition } from '../types';
 export declare function getEditableTableRows<T>(state: any, tableDataKey?: string): T[];
-/**
- * Wrap updated rows back into the parent state shape.
- */
 export declare function updateEditableTableRows<T>(state: any, updatedRows: T[], tableDataKey?: string): any;
-/**
- * Create a new row from defaultData template.
- * Uses tableDataKey to extract the row template from nested defaults.
- */
 export declare function createNewRow<T>(defaultData: T, rowKey: string, generateId: () => string, tableDataKey?: string): T;
-/**
- * Create a copied row from a source row, optionally limiting to specific keys.
- */
 export declare function createCopiedRow<T>(sourceRow: T, newRowTemplate: T, copyKeys: string[], rowKey: string, generateId: () => string): T;
-/**
- * Check if a cell is disabled based on column definition and row data.
- */
 export declare function isCellDisabled<T>(rowIndex: number, cellindex: number, tableRows: T[], columns: EditableTableColumnDefinition<T>[], defaultData: T, tableDataKey?: string, getRowField?: (context: {
     rowIndex: number;
     tableDataKey?: string;
 }) => EditableTableColumnDefinition<T>[]): boolean;
-/**
- * Pure grid navigation: find next focusable cell in a direction.
- * Returns target coordinates and whether a new row can be created.
- */
 export declare function findNextFocusableCell<T>(currentRowIndex: number, currentCellIndex: number, direction: 'forward' | 'backward', totalRows: number, totalColumns: number, fixedRows: boolean, checkDisabled: (rowIndex: number, cellindex: number) => boolean): {
     rowIndex: number;
     cellindex: number;
     found: boolean;
     canCreateNew?: boolean;
 };
-/**
- * Generate a random ID string.
- */
 export declare function generateEditableTableId(length?: number): string;
+export declare function cellFieldName(column: {
+    header?: unknown;
+    fprop?: Record<string, unknown>;
+}): string | undefined;

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

@@ -0,0 +1,12 @@
+import type { ControlSize } from '../types';
+export interface FieldControlClassOptions {
+    size?: string;
+    variant?: string;
+    error?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    hasAffix?: boolean;
+    popupOpen?: boolean;
+}
+export declare const buildFieldControlClassKeys: ({ size, variant, error, disabled, readOnly, hasAffix, popupOpen, }: FieldControlClassOptions) => string[];
+export declare function smallerSize(size: ControlSize): ControlSize;

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

@@ -1,4 +1,4 @@
-import type { FieldLayout, FieldSize } from '../../../published/dcs-ui/src/publicTypes';
+import type { FieldLayout, FieldSize } from '../types';
 export declare function buildFieldWrapperClassKeys(opts: {
     layout: FieldLayout;
     size?: FieldSize;

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

@@ -1,4 +1,4 @@
-import type { Condition, ConditionOperator, ConditionContext, ResetKeyConfig, SelectCopyKeyConfig, SelectAdditionalDataContext, ChangeContext, FieldDefinition, NestedKeys } from '../../../published/dcs-ui/src/publicTypes';
+import type { Condition, ConditionOperator, ConditionContext, ResetKeyConfig, SelectCopyKeyConfig, SelectAdditionalDataContext, ChangeContext, FieldDefinition, NestedKeys } from '../types';
 export declare function getValueByPath(obj: any, path: string): any;
 export declare function setValueByPath(obj: any, path: string, value: any): any;
 export declare function constructFullPath(fieldName: string, options?: {

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

@@ -1,7 +1,3 @@
-/**
- * Form Logic — Pure functions for form state management
- * No React, no DOM.
- */
 export interface FormClassKeyOptions {
     variant: string;
     size: string;
@@ -10,8 +6,4 @@ export interface FormClassKeyOptions {
     loading?: boolean;
 }
 export declare function buildFormClassKeys(opts: FormClassKeyOptions): string[];
-/**
- * Evaluate a boolean-or-function condition against data.
- * Used for section/action visible, disabled, loading props.
- */
 export declare function evaluateFormCondition<T>(condition: boolean | ((data: T) => boolean) | undefined, data: T, defaultValue: boolean): boolean;

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

@@ -0,0 +1,33 @@
+export * from './button.logic';
+export * from './cellRules.logic';
+export * from './checkbox.logic';
+export * from './chipinput.logic';
+export * from './collapsible.logic';
+export * from './colorScheme';
+export * from './columnOrder.logic';
+export * from './datePicker.logic';
+export * from './timeField.logic';
+export * from './editableTable.logic';
+export * from './fieldControl.logic';
+export * from './fieldWrapper.logic';
+export * from './fields.logic';
+export * from './form.logic';
+export * from './input.logic';
+export * from './keyboard.logic';
+export * from './motion.logic';
+export * from './navigation.logic';
+export * from './popover.logic';
+export * from './popupList.logic';
+export * from './press.logic';
+export * from './stepper.logic';
+export * from './quickAddGrid.logic';
+export * from './radio.logic';
+export * from './select.logic';
+export * from './suggest.logic';
+export * from './switch.logic';
+export * from './tableLayout.logic';
+export * from './tableSummary.logic';
+export * from './tooltip.logic';
+export * from './typography.logic';
+export * from './uiScale.logic';
+export * from './useMergeRefs';

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

@@ -0,0 +1,12 @@
+import type { FieldKeyboardConfig, KeyEventLike, KeyResolution, KeyResolutionContext, NavAction } from '../types';
+export declare function parseBinding(binding: string): string;
+export declare function eventBinding(event: KeyEventLike): string;
+export declare function matchBinding(event: KeyEventLike, binding: string): boolean;
+export declare const DEFAULT_GRID_BINDINGS: Record<string, NavAction>;
+export declare const DEFAULT_FORM_BINDINGS: Record<string, NavAction>;
+export declare const DEFAULT_KEYBOARD_CONFIG: Required<Pick<FieldKeyboardConfig, 'mode' | 'enter' | 'arrows' | 'arrowsInEdit' | 'typeBehaviour' | 'editKey' | 'openOn' | 'advanceOnSelect' | 'stepKeys'>>;
+export declare const GRID_CELL_KEYBOARD_DEFAULTS: FieldKeyboardConfig;
+export declare function isPrintableKey(event: KeyEventLike): boolean;
+export declare function resolveFieldKey(event: KeyEventLike, ctx: KeyResolutionContext): KeyResolution;
+export declare function nextFocusableIndex(count: number, current: number, direction: 'forward' | 'backward', isDisabled?: (index: number) => boolean, wrap?: boolean): number;
+export declare function resolveKeyboardConfig(own: FieldKeyboardConfig | undefined, inherited: FieldKeyboardConfig | undefined): FieldKeyboardConfig;

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

@@ -0,0 +1 @@
+export declare function transitionMsFor(property: string, properties: string, durations: string, delays: string): number;