@dcs-tech/ui 0.2.0 → 0.3.0

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

@@ -1,83 +1,50 @@
-/**
- * Quoin designer — the contracts its editors are built against.
- *
- * Every editor receives the template, the registry, and ONE way to change the template: `edit`,
- * which runs a pure operation from `shared-logic/report/edit` through the designer's undo history.
- * No editor keeps its own copy of the template or writes to it any other way — that is what makes
- * undo, the live preview and the Save gate properties of the designer rather than of each control.
- */
 import type { FieldType, PlaceholderFormat, ReportConditionGroup, ReportRegistry, ReportTemplate, TableBlock, TextStyle } from '../../../published/dcs-ui/src/publicTypes';
 import type { AlignedRowsTarget, DesignerSelection, FieldPlace } from '../../../published/dcs-ui/src/publicLogic';
-/** `coalesceKey` groups a run of keystrokes on one thing into a single undo step. */
 export type TemplateEdit = (change: (t: ReportTemplate) => ReportTemplate, coalesceKey?: string) => void;
 export interface EditorContext {
     template: ReportTemplate;
     registry: ReportRegistry;
     edit: TemplateEdit;
     onSelect: (selection: DesignerSelection) => void;
-    /**
-     * Which tab a panel was left on, kept OUTSIDE the panel.
-     *
-     * Panel state used to live in the panel, so returning from a column re-mounted the table editor
-     * on its first tab — you left from Columns and came back to Data, with the column you were
-     * editing off screen behind a tab you had to find again. Held here, leaving and coming back
-     * lands where you were.
-     */
     panelTab?: (key: string, fallback: string) => string;
     setPanelTab?: (key: string, value: string) => void;
 }
-/** Where a table-scoped editor points. */
 export interface TableAddress {
     bandId: string;
     blockId: string;
 }
-/**
- * "Print this only when …" — a list of rules matched all/any. Offers only the fields that resolve
- * where the condition sits (`place`, and `table` when inside one). `null` removes the condition.
- */
 export interface ConditionEditorProps {
     registry: ReportRegistry;
     template: ReportTemplate;
     table?: Pick<TableBlock, 'data'>;
-    /** Defaults to `condition`. */
     place?: FieldPlace;
     value?: ReportConditionGroup;
     onChange: (group: ReportConditionGroup | null) => void;
-    /** Heading shown above the rules. Defaults to "Show only when". */
     label?: string;
 }
 export type StyleControl = 'bold' | 'italic' | 'underline' | 'fontSize' | 'textCase' | 'color' | 'fill';
-/** A compact row of style toggles and inputs. `undefined` means "no style of its own". */
 export interface StyleEditorProps {
     value?: TextStyle;
     onChange: (style: TextStyle | undefined) => void;
-    /** Defaults to bold, italic, underline, font size and text case. */
     controls?: StyleControl[];
 }
-/** How a value prints: number decimals/grouping/sign, date pattern, prefix, suffix, empty text. */
 export interface FormatEditorProps {
     value?: PlaceholderFormat;
-    /** Picks the sensible first choice of format type. */
     fieldType?: FieldType;
     onChange: (format: PlaceholderFormat | undefined) => void;
 }
-/** One field of a row set, as a Select. */
 export interface FieldSelectProps {
     registry: ReportRegistry;
     rowSet?: string;
     value?: string;
     onChange: (key: string | undefined) => void;
     label?: string;
-    /** When set, a first option meaning "none", with this label. */
     noneLabel?: string;
-    /** Narrow the fields offered. */
     only?: 'aggregatable' | 'number';
 }
-/** Several fields of a row set, as checkboxes. */
 export interface FieldSetProps {
     label: string;
     hint?: string;
-    /** `group` sorts the chooser into named blocks; the group `Internal` is hidden until asked for. */
     fields: Array<{
         key: string;
         label: string;
@@ -86,21 +53,15 @@ export interface FieldSetProps {
     selected: string[];
     onChange: (keys: string[]) => void;
 }
-/** A table block: its data, heading, sections, closing rows, look, and the list of its columns. */
 export interface TableEditorProps extends EditorContext, TableAddress {
 }
-/** One column of a table. */
 export interface ColumnEditorProps extends EditorContext, TableAddress {
     columnId: string;
 }
-/** Rows aligned to a table's columns: its closing rows, or its sections' heading or subtotal rows. */
 export interface AlignedRowsEditorProps extends EditorContext, TableAddress {
     target: AlignedRowsTarget;
 }
-/** Any block that is not a table: text, image, QR, barcode, line, space — plus the settings every block has. */
 export interface BlockEditorProps extends EditorContext, TableAddress {
 }
-/** The template's print options. */
 export type OptionsEditorProps = EditorContext;
-/** The page watermark. */
 export type WatermarkEditorProps = EditorContext;

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

@@ -1,44 +1,20 @@
 import type { ReportContext, ReportRegistry, ReportTemplate } from '../../../published/dcs-ui/src/publicTypes';
 import { type CanvasHighlight, type CanvasTarget, type ValidationIssue } from '../../../published/dcs-ui/src/publicLogic';
-/**
- * Quoin — a live preview of a template.
- *
- * This is the designer's canvas, built before the designer. It renders through the HTML renderer
- * rather than pdfmake, which means no PDF toolchain in a shared package, redraw on every
- * keystroke, and — because the engine owns the layout — the same page boxes, column widths and
- * line breaks the PDF will have.
- *
- * It never throws. A template being edited is malformed most of the time; a preview that blanks
- * or crashes while someone is halfway through typing a field name is useless. Errors are shown
- * beside the pages, and whatever still renders is rendered.
- *
- * With `onTargetClick` it is also a surface to select from: the renderer tags every band and block
- * with its id, a click reports the nearest ones, and `highlight` outlines the current selection.
- * The outline is CSS added beside the pages rather than a change to the rendered HTML, so selecting
- * something never re-runs layout.
- */
 export interface ReportPreviewProps {
     template: ReportTemplate;
     context: ReportContext;
     registry: ReportRegistry;
-    /** Page edges and shadow. Off when embedding for print. */
     pageChrome?: boolean;
-    /** Hide the issue list even when there are issues — the designer may show them elsewhere. */
     hideIssues?: boolean;
-    /** Scale the pages, so a full A4 fits a panel. 1 = actual size. */
     zoom?: number;
     className?: string;
-    /** Called after each render with what validation found and how many pages resulted. */
     onRender?: (info: {
         issues: ValidationIssue[];
         pageCount: number;
         error?: string;
     }) => void;
-    /** Elements to outline as selected — see `canvasHighlight` in shared-logic. */
     highlight?: CanvasHighlight[];
-    /** A click on the pages, as the ids of the band and block under the pointer. */
     onTargetClick?: (target: CanvasTarget) => void;
 }
 export declare const ReportPreview: ({ template, context, registry, pageChrome, hideIssues, zoom, className, onRender, highlight, onTargetClick, }: ReportPreviewProps) => import("react").JSX.Element;
-/** Whether a template is safe to save, for a designer's Save button. */
 export declare const canSaveTemplate: (template: ReportTemplate, registry: ReportRegistry) => boolean;

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

@@ -0,0 +1,2 @@
+export declare function useScrollRule(): void;
+export declare function ScrollRule(): null;

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

@@ -0,0 +1,9 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+import { type ScrollLabels } from './labels';
+export interface ScrollStripProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children?: ReactNode;
+    frameClassName?: string;
+    step?: number;
+    labels?: Partial<ScrollLabels>;
+}
+export declare function ScrollStrip({ children, className, frameClassName, step, labels, ...rest }: ScrollStripProps): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+export { ScrollRule, useScrollRule } from './ScrollRule';
+export { ScrollStrip, type ScrollStripProps } from './ScrollStrip';
+export { SCROLL_FADE_SELECTOR, SCROLL_IDLE_MS, SCROLLING_CLASS, applyScrollEdges, installScrollActivity, isScrollActivityInstalled, readScrollEdges, type ScrollAxis, type ScrollEdges, } from './scrollActivity';
+export { DEFAULT_SCROLL_LABELS, type ScrollLabels } from './labels';

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

@@ -0,0 +1,5 @@
+export declare const DEFAULT_SCROLL_LABELS: {
+    scrollStart: string;
+    scrollEnd: string;
+};
+export type ScrollLabels = typeof DEFAULT_SCROLL_LABELS;

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

@@ -0,0 +1,14 @@
+export declare const SCROLLING_CLASS = "is-scrolling";
+export declare const SCROLL_IDLE_MS = 1000;
+export declare const SCROLL_FADE_SELECTOR = ".scroll-fade-x, .scroll-fade-y";
+export type ScrollAxis = 'x' | 'y';
+export interface ScrollEdges {
+    start: boolean;
+    end: boolean;
+}
+export declare function readScrollEdges(el: Element, axis: ScrollAxis): ScrollEdges;
+export declare function applyScrollEdges(el: Element): void;
+export declare function installScrollActivity(options?: {
+    idleMs?: number;
+}): () => void;
+export declare const isScrollActivityInstalled: () => boolean;

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

@@ -0,0 +1 @@
+export { Button } from '../Button';

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

@@ -2,38 +2,17 @@ import React from 'react';
 import type { NavItem } from '../../../published/dcs-ui/src/publicTypes';
 export type SidebarDensity = 'compact' | 'comfortable';
 export interface SidebarProps {
-    /** Already filtered and authorised by the caller. Depth is unbounded. */
     items: NavItem[];
-    /** `id` of the current page. Ancestors are marked as on-trail automatically. */
     activeId?: string | null;
     onSelect?: (item: NavItem) => void;
-    /** Element for each row — `NavLink`, `Link`, `a`. Defaults to `a` when an item has `href`. */
     as?: React.ElementType;
-    /**
-     * Row density. **`compact` by default** — a nav list is scanned, not read, and generous
-     * padding pushes real destinations below the fold. `comfortable` for touch.
-     */
     density?: SidebarDensity;
-    /**
-     * Icon-only rail. Children move into a hover flyout rather than disappearing.
-     * **Ignored below 600px**, where the sidebar is a drawer — a permanent 56px strip on a
-     * phone costs space and says little.
-     */
     collapsed?: boolean;
-    /**
-     * Drawer state below 600px, where the sidebar is off-canvas. Above it the sidebar is a
-     * column in the layout and this does nothing, so a desktop-only app can ignore it.
-     */
     open?: boolean;
-    /** Fired by the scrim and by Escape while the drawer is open. */
     onClose?: () => void;
     defaultExpandedIds?: string[];
     expandedIds?: string[];
     onExpandedChange?: (ids: string[]) => void;
-    /**
-     * Trailing controls for a row — a pin, a rename. Revealed on hover or focus-within, so a
-     * long list is not a wall of icons. The library stays out of what the action MEANS.
-     */
     renderItemActions?: (item: NavItem) => React.ReactNode;
     header?: React.ReactNode;
     footer?: React.ReactNode;
@@ -41,15 +20,5 @@ export interface SidebarProps {
     style?: React.CSSProperties;
     'aria-label'?: string;
 }
-/**
- * A navigation rail over the shared `NavItem` shape.
- *
- * It renders; it decides nothing. Building items from a route registry and filtering them by
- * permission is app logic — which is also what makes a **dynamic** registry work with no
- * special support: a runtime-generated branch is just a different array.
- *
- * The active TRAIL comes from `navTrailIds` in shared-logic, the same function Breadcrumbs uses
- * to render the path, so the two cannot disagree about where you are.
- */
 declare const Sidebar: React.FC<SidebarProps>;
 export default Sidebar;

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

@@ -2,32 +2,17 @@ import React from 'react';
 export type SkeletonVariant = 'text' | 'rect' | 'circle';
 export type SkeletonAnimation = 'shimmer' | 'pulse' | 'none';
 export interface SkeletonProps {
-    /** Shape of the placeholder. Default `'text'`. */
     variant?: SkeletonVariant;
     width?: number | string;
     height?: number | string;
-    /** Border-radius override (number = px). */
     radius?: number | string;
-    /** Repeat the placeholder N times, stacked. Default 1. */
     count?: number;
-    /** Gap between repeats (number = px). Default 8. */
     gap?: number | string;
-    /** Width of the LAST line when `count > 1`, for a natural paragraph finish. Default '65%'. */
     lastLineWidth?: number | string;
     animation?: SkeletonAnimation;
-    /** Render inline-block instead of block. */
     inline?: boolean;
     className?: string;
     style?: React.CSSProperties;
 }
-/**
- * Loading placeholder.
- *
- * Hookless and DOM-free on purpose: it renders identically on a server, which keeps it
- * eligible for a future server-safe entry point alongside Badge, Avatar and Card.
- *
- * Always `aria-hidden` — a screen reader should hear the loading STATE from the region that
- * owns it (`aria-busy`, or a live region), not a description of grey rectangles.
- */
 declare const Skeleton: React.FC<SkeletonProps>;
 export default Skeleton;

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

@@ -2,78 +2,35 @@ import React from 'react';
 export type TabsVariant = 'line' | 'pill' | 'enclosed';
 export type TabsSize = 'small' | 'medium';
 export interface TabItem {
-    /** Identifies the tab. Matched against `value` to decide the active one. */
     value: string;
     label: React.ReactNode;
     icon?: React.ReactNode;
-    /** Trailing count or marker. */
     badge?: React.ReactNode;
     disabled?: boolean;
-    /** Plain link target. Presence of this (or `as`) switches the strip to NAVIGATION mode. */
     href?: string;
-    /**
-     * Extra props for this item's element — how a router link gets its target, e.g.
-     * `{ to: '/businesses' }` for react-router's `NavLink`. Router-agnostic on purpose.
-     */
     props?: Record<string, unknown>;
 }
 export interface TabsProps {
     items: TabItem[];
-    /** The active tab's `value`. */
     value?: string;
-    /** Panel mode only — navigation mode leaves activation to the router. */
     onChange?: (value: string, item: TabItem) => void;
-    /**
-     * Element to render each tab with — `NavLink`, `Link`, `a`. Supplying it (or any item
-     * `href`) switches to NAVIGATION mode; see the semantics note on the component.
-     */
     as?: React.ElementType;
     variant?: TabsVariant;
     size?: TabsSize;
-    /** Stretch tabs to fill the strip. */
     fullWidth?: boolean;
-    /**
-     * Panel mode: move activation with arrow focus. Default true, which is right when panels
-     * are cheap to render; set false when switching a tab costs a fetch.
-     */
     activateOnFocus?: boolean;
-    /** Ties panels to tabs. Auto-generated if omitted. */
     idPrefix?: string;
     className?: string;
     style?: React.CSSProperties;
     'aria-label'?: string;
 }
-/**
- * A tab strip in one of two modes, inferred from the items.
- *
- * **Panel mode** (default) — buttons in a `role="tablist"`, following the WAI-ARIA tabs
- * pattern: roving tabindex, arrows, Home/End, disabled skipped.
- *
- * **Navigation mode** — used as soon as an item has `href` or `as` is supplied. Renders a
- * `<nav>` of ordinary links: **no `role="tab"`, no roving tabindex**, and the active link gets
- * `aria-current="page"`.
- *
- * That split is not cosmetic. `role="tab"` promises the element controls a panel in the SAME
- * document; putting it on a link that navigates away lies to a screen reader, and the roving
- * tabindex the pattern requires would also remove every other tab from the tab order — wrong
- * for what is really a nav bar. Both apps here navigate by route (the console's `NavLink`s,
- * the client's `useParams` + component map), so navigation mode is the common case, not the
- * afterthought.
- */
 declare const Tabs: React.FC<TabsProps>;
 export interface TabPanelProps {
-    /** Must match the tab's `value`. */
     value: string;
-    /** The strip's `idPrefix`, so the panel can point back at its tab. */
     idPrefix: string;
-    /** Rendered only when active. */
     active: boolean;
     children?: React.ReactNode;
     className?: string;
 }
-/**
- * Panel-mode content, wired to its tab. Panel mode only — in navigation mode the router owns
- * what is on screen and there is nothing here to label.
- */
 export declare const TabPanel: React.FC<TabPanelProps>;
 export default Tabs;

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

@@ -1,22 +1,8 @@
 import React from 'react';
 import type { ToastApi, ToastDefaults } from './toast.types';
-/**
- * Fire a toast from anywhere below the `UIProvider`.
- *
- * Throws without one rather than no-opping: a swallowed error toast is worse than a crash at
- * wire-up time, because the failure it was reporting then disappears silently too.
- */
 export declare const useToast: () => ToastApi;
 export interface ToastHostProps {
     defaults?: ToastDefaults;
     children?: React.ReactNode;
 }
-/**
- * Rendered once by `UIProvider`. Owns the toast queue and the position regions.
- *
- * Central hosting is the point: `react-toastify` needs a `<ToastContainer>` mounted by hand,
- * which every consuming app has to remember and configure identically. Here the provider does
- * it, and the provider is also the abstraction boundary — this implementation can change
- * without any call site knowing.
- */
 export declare const ToastHost: React.FC<ToastHostProps>;

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

@@ -2,18 +2,9 @@ import React from 'react';
 import type { ToastRecord } from './toast.types';
 interface ToastItemProps {
     toast: ToastRecord;
-    /** Window focus is tracked once by the host, not per toast. */
     windowFocused: boolean;
     onDismiss: (id: string) => void;
     exitDuration: number;
 }
-/**
- * One toast. Owns its own dismiss timer so `pauseOnHover` can be per-toast rather than
- * freezing the whole stack.
- *
- * The timer keeps a REMAINING budget rather than restarting: pausing subtracts elapsed time,
- * resuming schedules what's left. Restarting on every hover would make a toast the user keeps
- * brushing past effectively permanent.
- */
 declare const ToastItem: React.FC<ToastItemProps>;
 export default ToastItem;

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

@@ -1,25 +1,9 @@
 import React from 'react';
 import type { TooltipProp, TooltipProps } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * Wraps any single element in a tooltip:
- *
- *   <Tooltip content="Delete row"><IconButton …/></Tooltip>
- *
- * The child is cloned, not wrapped — the old client tooltip put a <div> around
- * its trigger, which silently broke flex and grid layouts wherever it was used.
- *
- * Components with their own `tooltip` prop (Button, the fields, Collapsible,
- * Typography) call `useTooltip` directly instead of nesting this.
- */
 export declare const Tooltip: React.FC<TooltipProps>;
 export interface TooltipHelpIconProps {
     tooltip: TooltipProp;
-    /** Names the icon for screen readers. The tooltip itself is the description. */
     label?: string;
 }
-/**
- * The ⓘ that sits after a field label. It is a real button so it is reachable by
- * Tab — a plain <span> tooltip is invisible to keyboard users.
- */
 export declare const TooltipHelpIcon: React.FC<TooltipHelpIconProps>;
 export default Tooltip;

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

@@ -1,7 +1,6 @@
 import React from 'react';
 import type { TooltipProp } from '../../../published/dcs-ui/src/publicTypes';
 export interface UseTooltipResult {
-    /** Spread onto whatever element should trigger the tooltip. */
     triggerProps: {
         onPointerEnter: (event: React.PointerEvent<HTMLElement>) => void;
         onPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
@@ -10,15 +9,7 @@ export interface UseTooltipResult {
         onBlur: () => void;
         'aria-describedby'?: string;
     };
-    /** Render next to the trigger. Empty when there is no tooltip. */
     tooltipNode: React.ReactNode;
-    /** True when a tooltip is actually configured. */
     hasTooltip: boolean;
 }
-/**
- * Hover/focus tooltip built on the Popover API: the tip lives in the top layer,
- * so no portal, no z-index management, and no clipping by an `overflow: hidden`
- * ancestor — which is what breaks tooltips inside table cells and inside
- * Collapsible items (they carry `contain: layout style paint`).
- */
 export declare function useTooltip(tooltip: TooltipProp | undefined): UseTooltipResult;

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

@@ -1,16 +1,2 @@
-/**
- * Where floating layers (Select and Suggest dropdowns today; Dialog and Popover when they
- * land) render.
- *
- * `null` means "no provider" — every consumer falls back to `document.body`, which is what
- * they did before this context existed. So adding the context changed nothing for apps that
- * do not mount a `UIProvider`.
- *
- * Why it is worth having one owned node rather than body: everything floating shares a single
- * stacking context that the library controls. Portalling straight to body puts each layer in
- * whatever z-index race the host app happens to have — the class of problem behind the
- * loading overlay that covered a confirm dialog and locked the app.
- */
 export declare const UIPortalContext: import("react").Context<HTMLElement | null>;
-/** The container floating layers should portal into. Falls back to `document.body`. */
 export declare const useUIPortalContainer: () => HTMLElement | null;

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

@@ -4,51 +4,10 @@ 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 to apply, written to `data-theme` on the root element.
-     *
-     * **Omit it entirely** if the host app already manages `data-theme` — the provider then
-     * never touches the DOM, and `useUITheme` throws rather than pretending to be in charge.
-     * `'system'` follows the OS and keeps following it.
-     */
     theme?: UITheme;
-    /** Called whenever the theme changes, including the first resolve of `'system'`. */
     onThemeChange?: (resolved: ResolvedUITheme, requested: UITheme) => void;
-    /**
-     * Node for floating layers to portal into. Pass one to control placement yourself;
-     * omit and the provider creates and owns a single container appended to `<body>`.
-     * Pass `false` to opt out entirely, leaving every layer on `document.body`.
-     */
     portalContainer?: HTMLElement | false;
-    /**
-     * Defaults for every toast — position, autoClose, limit, newestOnTop. The host is mounted
-     * either way; this only configures it, so `useToast()` works with no setup.
-     */
     toast?: ToastDefaults;
 }
-/**
- * One optional wrapper for everything a design system needs at RUNTIME: the theme, a stacking
- * context for floating layers, and field defaults for the tree below.
- *
- * Optional is the point. Every component works standalone with sensible defaults — this only
- * ADDS. A library that throws without its provider turns a one-line install into a setup
- * chore.
- *
- * Its real value is not the saved setup line, it is that it is an abstraction boundary: the
- * portal container can change, a toast host can appear, theming can gain persistence — none
- * of which is a breaking change for anyone already wrapping their app.
- *
- * It DOES host the dialog and toast layers (`useDialog`, `useToast`), because both need a host
- * somewhere and making every call site render one is the mistake this replaces.
- *
- * NOT here on purpose:
- *  - **Stylesheet.** `import '@dcs-tech/ui/style.css'` stays explicit. Side-effect importing
- *    it from the bundle takes CSS-order control away from consumers and breaks in setups that
- *    do not process CSS imports out of node_modules.
- *
- * It also hosts the toast layer (`useToast`), for the same reason — and because owning it is
- * what removes `react-toastify`'s `<ToastContainer>` mount contract, which every consuming app
- * would otherwise have to remember and configure identically.
- */
 declare const UIProvider: React.FC<UIProviderProps>;
 export default UIProvider;

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

@@ -1,6 +1,4 @@
-/** What the app asks for. `system` follows the OS and keeps following it. */
 export type UITheme = 'light' | 'dark' | 'system';
-/** What is actually on screen — `system` is resolved to one of the two. */
 export type ResolvedUITheme = 'light' | 'dark';
 export interface UIThemeValue {
     theme: UITheme;
@@ -8,10 +6,4 @@ export interface UIThemeValue {
     setTheme: (theme: UITheme) => void;
 }
 export declare const UIThemeContext: import("react").Context<UIThemeValue | null>;
-/**
- * Read or change the theme.
- *
- * Throws outside a `UIProvider` that manages theme, rather than returning a plausible
- * default: a silent `'light'` would make a broken toggle look like a working one.
- */
 export declare const useUITheme: () => UIThemeValue;

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

@@ -22,6 +22,8 @@ export { Input } from './Input';
 export type { InputProps, InputType, InputVariant, InputSize, InputLayout, ValidationConfig, IconConfig, } from './Input';
 export { Select, useSelect } from './Select';
 export type { SelectProps, SelectOption, SelectSize, SelectLayout, SelectState, SelectEvent, SelectAccessibilityConfig, UseSelectReturn, UseSelectConfig, MultiSelectConfig, SearchConfig, SortConfig, ReorderConfig, GroupConfig, VirtualScrollConfig, KeyboardConfig, DropdownPosition, PositionConfig, EmptyStateConfig, LoadingConfig, ChipProps, GroupDisplayProps, OptionItemProps, AutoScrollState, DropdownDimensions, OptionValue, } from './Select';
+export { DatePicker, Calendar } from './DatePicker';
+export type { DatePickerProps, DatePickerBaseProps, DatePickerSingleProps, DatePickerRangeProps, DateRangeValue, DateDisplayFormat, DateTextOrder, CalendarProps, } from './DatePicker';
 export { Suggest, SuggestionList, useSuggest } from './Suggest';
 export { FORMATTER_UTILITY_CLASSES, SUGGEST_SEARCH_ENGINE_OPTIONS, SUGGEST_SEARCH_MODE_OPTIONS, } from './Suggest';
 export type { SuggestProps, SuggestSize, SuggestLayout, SuggestSearchEngine, SuggestSearchMode, RenderKey, SuggestionConfig, SuggestionItemProps, SuggestionListProps, SuggestionGroup, UseSuggestOptions, UseSuggestReturn, SuggestSearchOptions, } from './Suggest';
@@ -37,6 +39,9 @@ export { parseFormat, resolveFormat, extractPlaceholders, validateFormat, } from
 export type { ChipInputProps, ChipInputSize, ChipInputLayout, ChipKey, ChipSource, ChipSources, ChipSuggestionItem, GroupedSuggestions, ParsedSegment, ResolveOptions, ExtractedPlaceholder, FormatValidationResult, UseChipSuggestionsOptions, UseChipSuggestionsReturn, } from './ChipInput';
 export { EditableTable, EditableTableRow, EditableTableActions, EditableTableCell, EditableTableSummary, useEditableTable } from './EditableTable';
 export type { EditableTableProps, EditableTableRowProps, EditableTableActionsProps, EditableTableColumnDefinition, EditableTableFocusState, EditableTableCopyConfig, EditableTableAddConfig, EditableTableDeleteConfig, EditableTableFooterConfig, EditableTableSummaryContext, EditableTableSummaryActions, TableColumnDisplayProps, TableSummaryConfig, ColumnSummaryConfig, SummaryItem, SummaryGroup, CellStyle, ColumnAlign, ColumnSticky, } from './EditableTable';
+export * from './DataTable';
+export * from './Charts';
+export * from './Scroll';
 export { ColorSchemeSelect } from './ColorSchemeSelect';
 export type { ColorSchemeSelectProps } from './ColorSchemeSelect';
 export { UIProvider, useUIPortalContainer, useUITheme } from './UIProvider';