@dcs-tech/ui 0.2.0 → 0.3.0

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

@@ -1,43 +1,11 @@
-/**
- * Row enter/exit feedback for the grid.
- *
- * GK: *"on click remove, dont know it is removed or not, also dont know from where the focus
- * is shifted."* Both halves matter. A row that vanishes between two frames reads as "nothing
- * happened", and after a delete the grid focuses the row ABOVE the one that went — useful, but
- * invisible, so the cursor appears to teleport.
- *
- * Three pieces, and each is deliberately small:
- *
- * - **entering** — keys present now that were absent last render. Detected by DIFFING the keys
- *   rather than by hooking the add path, so it covers every way a row arrives: Enter at the
- *   last cell (which happens inside `useEditableTable`, out of the renderer's reach), the
- *   toolbar, a button cell's `actions.addRow`, or the consumer setting state itself.
- * - **exiting** — a delete has to be DEFERRED for the row to be animated at all; React cannot
- *   animate a row it has already unmounted. The delay is short and the focus move is not
- *   waited on, so the keyboard flow is unchanged.
- * - **landed** — the cell focus ends up in, flashed briefly, which is the half that answers
- *   "where did it go".
- *
- * `prefers-reduced-motion` switches all of it off, including the deferral: someone who asked
- * for no animation should not also get a slower delete.
- */
-/**
- * Kept in step with the durations in `EditableTable.module.css` — `etRowExitCell` and
- * `etRowEnterCell`. If this is SHORTER than the CSS, React unmounts the row mid-collapse and
- * the rows below snap up, which is the whole thing the animation exists to prevent.
- */
 export declare const ROW_EXIT_MS = 280;
 export interface RowAnimation {
-    /** `'entering' | 'exiting' | undefined` for a row key — rendered as a data attribute. */
     rowState: (rowKey: string) => 'entering' | 'exiting' | undefined;
-    /** The cell that focus landed on after a row operation, flashed so it can be seen. */
     landedCell: {
         rowKey: string;
         cellindex: number;
     } | null;
-    /** Runs `remove` after the exit animation — immediately when animation is off. */
     removeRow: (rowKey: string | undefined, remove: () => void) => void;
-    /** Called once focus has settled after an add or a delete. */
     noteLanding: (rowKey: string | undefined, cellindex: number) => void;
     enabled: boolean;
 }

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

@@ -1,18 +1,3 @@
 import type { FieldContextValue } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * The surface settings a container hands down to every field inside it.
- *
- * Before this existed, `<Form size="large">` styled the form's own chrome and
- * its action buttons and nothing else — the fields inside kept their own
- * defaults, which were `small` for Input/Select/Suggest and `medium` for
- * Checkbox/Radio/Switch. So a form had three densities in it and no single
- * prop could change them.
- *
- * Empty by default rather than pre-filled: a context that already carried
- * `size: 'small'` would be indistinguishable from a container that had
- * deliberately asked for small, and a field could no longer tell "nobody said"
- * from "someone said small". Resolution is always
- * `own prop → context → DEFAULT_CONTROL_SIZE`.
- */
 export declare const FieldContext: import("react").Context<FieldContextValue>;
 export declare const useFieldContext: () => FieldContextValue;

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

@@ -1,13 +1,4 @@
 import React from 'react';
 import type { FieldProviderProps } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * Supplies surface defaults to every field beneath it.
- *
- * Providers nest: an inner one overrides only the settings it names, so a
- * `<FieldProvider size="xs">` inside a `<Form variant="filled">` gives dense
- * filled fields rather than dense outlined ones. That is what makes the
- * editable-table row work — the grid sets `size` per table without having to
- * know or restate the variant the surrounding form chose.
- */
 declare const FieldProvider: React.FC<FieldProviderProps>;
 export default FieldProvider;

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

@@ -2,22 +2,7 @@ import type React from 'react';
 import { DEFAULT_KEYBOARD_CONFIG } from '../../../published/dcs-ui/src/publicLogic';
 import type { FieldHandle, FieldKeyboardConfig, FieldWidget, OpenReason } from '../../../published/dcs-ui/src/publicTypes';
 import { type FieldSurfaceDefaults, type FieldSurfaceInput, type ResolvedFieldSurface, type ResolvedToggleSurface } from './useFieldSurface';
-/**
- * The runtime half of the field contract.
- *
- * `BaseFieldProps` makes the *shape* uniform; a shape alone is a convention, and
- * the next person can still hand-wire a handler that behaves differently from
- * the other six. `useFieldSurface` showed the fix: make the only convenient path
- * the correct one. This is that for the whole field.
- *
- * A field author never calls `resolveFieldKey`, never decides what Escape does
- * and never writes an `onKeyDown` — they spread `field.handlers` onto their
- * control. A field that skips this hook gets no `mode`, no arbitration and no
- * handle, so it **visibly** does not work in a grid rather than working subtly
- * wrong in one corner nobody tests.
- */
 export interface UseFieldOptions<E extends HTMLElement = HTMLElement> extends FieldSurfaceInput {
-    /** Drives the keyboard truth table. `'number'` and `'text'` are one component, two widgets. */
     widget: FieldWidget;
     elementRef: React.RefObject<E | null>;
     keyboard?: FieldKeyboardConfig;
@@ -27,33 +12,22 @@ export interface UseFieldOptions<E extends HTMLElement = HTMLElement> extends Fi
     open?: boolean;
     defaultOpen?: boolean;
     onOpenChange?: (open: boolean, reason: OpenReason) => void;
-    /** An empty list must not swallow Enter — see the resolver's L2 carve-out. */
     hasOptions?: boolean;
     multi?: boolean;
     rowIndex?: number;
     cellindex?: number;
     onCellFocus?: (rowIndex: number, cellindex: number) => void;
     registerCellRef?: (rowIndex: number, cellindex: number, ref: any) => void;
-    /** Identity, for the label/description ids the wrapper needs. */
     id?: string;
-    /** What the field does with a key it keeps, beyond letting it through. */
     onFieldAction?: (action: string, event: React.KeyboardEvent<E>) => void;
-    /** Restores the value a cell had before editing, for `revert`. */
     onRevert?: () => void;
-    /** Empties the cell without entering it, for `clear`. */
     onClear?: () => void;
     surfaceDefaults?: FieldSurfaceDefaults;
-    /**
-     * Which surface axis this field takes. `'toggle'` routes to
-     * `useToggleSurface`, which drops an inherited `underlined` — a checkbox has
-     * no text line, so it would render with neither border nor fill.
-     */
     surfaceKind?: 'control' | 'toggle';
 }
 export interface UseFieldResult<E extends HTMLElement = HTMLElement, S = ResolvedFieldSurface> {
     surface: S;
     keyboard: FieldKeyboardConfig;
-    /** `'navigate'` only ever happens in grid mode; a standalone field is always editable. */
     mode: 'navigate' | 'edit';
     isOpen: boolean;
     setOpen: (open: boolean, reason?: OpenReason) => void;
@@ -66,7 +40,6 @@ export interface UseFieldResult<E extends HTMLElement = HTMLElement, S = Resolve
         onFocus: (event: React.FocusEvent<E>) => void;
         onBlur: (event: React.FocusEvent<E>) => void;
         onKeyDown: (event: React.KeyboardEvent<E>) => void;
-        /** Spread on the control's WRAPPER, so its padding is not a dead zone. */
         onMouseDown: (event: React.MouseEvent<E>) => void;
     };
     handle: FieldHandle;

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

@@ -17,19 +17,6 @@ export interface ResolvedFieldSurface {
     disabled: boolean;
     readOnly: boolean;
 }
-/**
- * Resolves the four settings every field shares, in one place and one order:
- * **own prop → enclosing FieldContext → the component's default**.
- *
- * Each field used to bake this into its destructuring defaults, which is how
- * the size scale drifted apart — nothing forced the six components to agree,
- * and nothing let a container override them at all.
- *
- * `disabled` deliberately lets an explicit prop win over the container rather
- * than OR-ing the two, so a single always-enabled control inside a disabled
- * form is expressible. A container that means "everything, no exceptions"
- * should render a `<fieldset disabled>`, which the DOM enforces.
- */
 export declare function useFieldSurface(own: FieldSurfaceInput, defaults?: FieldSurfaceDefaults): ResolvedFieldSurface;
 export interface ResolvedToggleSurface {
     size: ControlSize;
@@ -37,16 +24,6 @@ export interface ResolvedToggleSurface {
     disabled: boolean;
     readOnly: boolean;
 }
-/**
- * The toggle counterpart. Checkbox and Radio take `ToggleVariant`, a subset —
- * they have no text line, so `underlined` has no styling behind it and would
- * render a box with neither border nor fill.
- *
- * An inherited `underlined` is therefore **dropped rather than passed through**,
- * and the toggle keeps its own default. Without that, `<Form variant="underlined">`
- * would silently erase every checkbox in the form — the exact bug §3 of the
- * handoff doc records from over-unifying `variant` the first time.
- */
 export declare function useToggleSurface(own: {
     size?: ControlSize;
     variant?: ToggleVariant;

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

@@ -2,11 +2,8 @@ import type React from 'react';
 import type { FieldKeyboardConfig } from '../../../published/dcs-ui/src/publicTypes';
 export interface UseFormKeyboardOptions {
     formRef: React.RefObject<HTMLElement | null>;
-    /** What Enter does. Anything but `'next'` leaves the browser alone. */
     enter?: FieldKeyboardConfig['enter'];
-    /** Called for `submit` — both Ctrl+Enter and Enter past the last field. */
     onSubmit?: () => void;
-    /** Extra policy merged into what the provider hands down. */
     keyboard?: FieldKeyboardConfig;
 }
 export declare function useFormKeyboard({ formRef, enter, onSubmit, keyboard, }: UseFormKeyboardOptions): FieldKeyboardConfig;

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

@@ -1,22 +1,7 @@
 import React from 'react';
 import type { ButtonCellContext, ButtonProps, EditableTableCellActions, FieldHandle } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * A button that is a grid CELL.
- *
- * `Field` used to render a bare `<Button>` for a `button` column. It never went through
- * `useField`, so it registered no cell handle — the arrows tried to land on it and the
- * cursor simply stalled, because `focusCellInRow` had nothing to focus. It also had no way
- * to know which row it was in: `fprop.onClick` received the DOM event and nothing else.
- *
- * Both are fixed here rather than in `Button`, which has no rest-prop spread and should not
- * learn about tables: the wrapper owns the cell wiring, `Button` stays a button.
- *
- * The keyboard needs no special case — `widget: 'button'` resolves Space to the browser
- * (which presses it) and leaves Enter with the grid's one meaning, walk on.
- */
 export interface FieldButtonProps<T> {
     fprop?: Partial<ButtonProps>;
-    /** The column-level handler, which takes the row/cell context instead of the event. */
     onColumnClick?: (context: ButtonCellContext<T>) => void;
     disabled?: boolean;
     value?: any;

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

@@ -0,0 +1,3 @@
+export { useFloatingLayer, type FloatingLayerOptions, type FloatingLayerResult } from './useFloatingLayer';
+export { LAYER_ATTR, LAYER_PROPS, isTopLayer, ownsFocus } from './layers';
+export { lockScroll, useScrollLock } from './scrollLock';

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

@@ -0,0 +1,4 @@
+export declare const LAYER_ATTR = "data-ui-layer";
+export declare const LAYER_PROPS: Readonly<Record<string, string>>;
+export declare function isTopLayer(el: Element): boolean;
+export declare function ownsFocus(el: Element): boolean;

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

@@ -0,0 +1,2 @@
+export declare function lockScroll(): () => void;
+export declare function useScrollLock(active: boolean): void;

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

@@ -0,0 +1,20 @@
+import { type RefObject } from 'react';
+export interface FloatingLayerOptions {
+    ref: RefObject<HTMLElement | null>;
+    onClose: () => void;
+    onEscape?: () => void;
+    open?: boolean;
+    anchorRef?: RefObject<HTMLElement | null>;
+    closeOnEscape?: boolean;
+    escapeNeedsFocus?: boolean;
+    closeOnOutside?: boolean;
+    closeOnScroll?: boolean;
+    closeOnResize?: boolean;
+    autoFocus?: boolean | 'self' | string;
+    restoreFocus?: boolean;
+    lockScroll?: boolean;
+}
+export interface FloatingLayerResult {
+    layerProps: Record<string, string>;
+}
+export declare function useFloatingLayer({ ref, onClose, onEscape, open, anchorRef, closeOnEscape, escapeNeedsFocus, closeOnOutside, closeOnScroll, closeOnResize, autoFocus, restoreFocus, lockScroll, }: FloatingLayerOptions): FloatingLayerResult;

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

@@ -1,44 +1,25 @@
 import React from 'react';
-import { type PopoverPlacement } from '../../../published/dcs-ui/src/publicLogic';
+import type { PopoverPlacement } from '../../../published/dcs-ui/src/publicLogic';
+import { type FloatingAnchor } from './floatingPosition';
 export interface PopoverProps {
-    /** Controlled. The caller owns open state — a primitive shouldn't guess. */
     open: boolean;
-    /** The element to position against. */
-    anchorEl: HTMLElement | null;
-    /** Fired for outside click, Escape, or scroll-away. Not called on internal clicks. */
+    anchorEl: FloatingAnchor | null;
     onClose?: () => void;
     children?: React.ReactNode;
     placement?: PopoverPlacement;
-    /** Gap between anchor and content, px. Default 4. */
     offset?: number;
-    /** Force the content to the anchor's width — what a select-style dropdown wants. */
     matchAnchorWidth?: boolean;
-    /** Default padding inside the surface. Off for menus and lists, which pad their own rows. */
     padded?: boolean;
     closeOnOutsideClick?: boolean;
     closeOnEscape?: boolean;
-    /** Move focus into the popover when it opens. Default true. */
-    autoFocus?: boolean;
-    /** Return focus to the anchor on close. Default true. */
+    onEscape?: () => void;
+    autoFocus?: boolean | string;
     returnFocus?: boolean;
     className?: string;
     style?: React.CSSProperties;
-    /** Announced role. `dialog` for forms, `menu` when it holds menu items. */
     role?: 'dialog' | 'menu' | 'listbox' | 'none';
     'aria-label'?: string;
+    'aria-busy'?: boolean;
 }
-/**
- * A positioned floating surface.
- *
- * Geometry comes from `computePopoverPosition` in shared-logic — the same function Select
- * uses, so "below the trigger" means one thing across the library rather than two.
- *
- * Positioning runs in two passes: render hidden to measure the content, then place it. That is
- * what makes `flip` and `shift` possible at all — neither can be decided without knowing how
- * big the box is. The first pass is `visibility: hidden`, so nothing appears at the wrong
- * coordinates in between.
- *
- * Portals into the `UIProvider` container when one is mounted, `document.body` otherwise.
- */
 declare const Popover: React.FC<PopoverProps>;
 export default Popover;

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

@@ -0,0 +1,17 @@
+import { type ComputePopoverPositionInput, type PopoverPosition } from '../../../published/dcs-ui/src/publicLogic';
+export declare const getFloatingOrigin: (container: Element | null) => {
+    x: number;
+    y: number;
+};
+export type FloatingAnchor = Element | {
+    top: number;
+    left: number;
+    width?: number;
+    height?: number;
+};
+export interface PlaceFloatingInput extends Omit<ComputePopoverPositionInput, 'anchor' | 'viewport' | 'scroll' | 'origin' | 'content'> {
+    anchor: FloatingAnchor;
+    container: Element | null;
+    contentEl?: HTMLElement | null;
+}
+export declare const placeFloating: ({ anchor, container, contentEl, ...rest }: PlaceFloatingInput) => PopoverPosition;

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

@@ -2,14 +2,6 @@ import type { BandKind, ReportRegistry, ReportTemplate } from '../../../publishe
 import type { DesignerSelection } from '../../../published/dcs-ui/src/publicLogic';
 import { BAND_KINDS } from './labels';
 export { BAND_KINDS };
-/**
- * Quoin — the document's structure, as a tree.
- *
- * The page and its print options first, then the bands in print order, each with its blocks, and
- * each table with its columns. One row is selected at a time and the inspector edits exactly that
- * row; a click on the page selects the same way. Anything carrying a condition says so in its hint,
- * so nothing prints — or disappears — for a reason the tree does not show.
- */
 export interface BandListProps {
     template: ReportTemplate;
     registry: ReportRegistry;

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

@@ -2,17 +2,14 @@ import { type ReactNode } from 'react';
 import type { Band, ReportConditionGroup, ReportRegistry, ReportTemplate, TextBlock, TextCell, TextRow } from '../../../published/dcs-ui/src/publicTypes';
 import { type DesignerSelection, type FieldPlace } from '../../../published/dcs-ui/src/publicLogic';
 import type { BlockEditorProps, TemplateEdit } from './types';
-/** A badge saying when something prints; a click opens the rules. */
 export declare const ConditionToggle: ({ registry, template, value, onChange, what, }: {
     registry: ReportRegistry;
     template: ReportTemplate;
-    /** Where the guarded thing sits. Conditions read fields as conditions do, wherever that is. */
     place?: FieldPlace;
     value?: ReportConditionGroup;
     onChange: (group: ReportConditionGroup | null) => void;
     what?: string;
 }) => import("react").JSX.Element;
-/** Where a block's text is being written, so only fields that resolve there are offered. */
 export declare const placeOf: (band: Band) => FieldPlace;
 interface TextProps {
     template: ReportTemplate;
@@ -21,20 +18,12 @@ interface TextProps {
     bandId: string;
     block: TextBlock;
     place: FieldPlace;
-    /** Rows and columns are places to go to, not things to unfold in situ. */
     onSelect: (selection: DesignerSelection) => void;
 }
-/**
- * One row of a text block: what it is, and the columns in it.
- *
- * Its columns are listed, not unfolded — opening one puts it in the panel on its own, with a path
- * above it saying where it came from.
- */
 export declare const TextRowPanel: (props: TextProps & {
     row: TextRow;
     index: number;
 }) => import("react").JSX.Element;
-/** One column of one row of a text block: how wide it is, and the lines it prints. */
 export declare const TextCellPanel: (props: TextProps & {
     row: TextRow;
     cell: TextCell;

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

@@ -1,7 +1,5 @@
 import type { ReportConditionGroup, ReportRegistry } from '../../../published/dcs-ui/src/publicTypes';
 import type { ConditionEditorProps } from './types';
-/** A field path in the author's words, without needing to know where it sits. */
 export declare const fieldLabel: (path: string, registry: ReportRegistry) => string;
-/** One sentence for a condition: "Only when Interstate (IGST) is Yes". Empty when there is none. */
 export declare const conditionSummary: (group: ReportConditionGroup | undefined, registry: ReportRegistry) => string;
 export declare const ConditionEditor: ({ registry, template, table, place, value, onChange, label, }: ConditionEditorProps) => import("react").JSX.Element;

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

@@ -1,24 +1,11 @@
 import type { ReportRegistry, TableBlock, TemplateOption } from '../../../published/dcs-ui/src/publicTypes';
 import { type FieldPlace } from '../../../published/dcs-ui/src/publicLogic';
-/**
- * Quoin — pick a field instead of typing one.
- *
- * A template author must never type `%party.mobil%` and discover it on a printed invoice, so the
- * whole vocabulary is offered as a list. What appears depends on where it will be inserted — row
- * fields only in a table, group values only where a table groups, totals only where they cover
- * something — and `scopeFor` decides, the same rule the validator enforces on Save.
- */
 export interface FieldPickerProps {
     registry: ReportRegistry;
-    /** Where the field will be inserted. */
     place: FieldPlace;
-    /** The table it sits in, when it does. */
     table?: Pick<TableBlock, 'data'>;
-    /** The template's print options, offered as fields. */
     templateOptions?: TemplateOption[];
-    /** Called with the text to insert, e.g. `%party.name%`. */
     onInsert: (insert: string) => void;
-    /** Shown when nothing matches the search. */
     emptyLabel?: string;
     maxHeight?: number;
 }

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

@@ -1,13 +1,6 @@
 import { type DesignerSelection } from '../../../published/dcs-ui/src/publicLogic';
 import type { EditorContext } from './types';
 export type { TemplateEdit } from './types';
-/**
- * Quoin — the inspector: settings for exactly what is selected, and nothing else.
- *
- * One selection, one panel — the page, the print options, a band, a block, or one column of a table.
- * Every panel ends with what decides whether the thing prints at all, so a line that "never shows"
- * always has its reason on screen.
- */
 export interface InspectorProps extends EditorContext {
     selection: DesignerSelection;
 }

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

@@ -1,34 +1,12 @@
 import { type ReactNode } from 'react';
 import type { ReportContext, ReportRegistry, ReportTemplate } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * Quoin — the designer.
- *
- * Laid out the way the Receipt Designer proved works: a toolbar across the top, then structure on
- * the left, the real page in the middle and an inspector on the right, each scrolling on its own.
- * One thing is selected at a time — from the tree or by clicking the page — it is outlined on the
- * page, and the inspector edits exactly that.
- *
- * Every change goes through `applyTemplateEdit`, so undo is a property of the design rather than
- * something each control has to remember, and the preview is the real engine — what is on screen
- * is what will print.
- *
- * Save is gated on validation, not on every intermediate state being valid: a template is malformed
- * for most of the time it is being edited, and refusing those states makes an editor unusable.
- * Where a saved template goes is the app's business — this hands a valid one to `onSave`.
- */
 export interface ReportDesignerProps {
-    /** Starting point — usually a shipped seed template. */
     template: ReportTemplate;
     registry: ReportRegistry;
-    /** Sample data. Real data makes the preview worth looking at; a stub makes it a wireframe. */
     context: ReportContext;
-    /** Called with a valid template. Absent hides the Save button. */
     onSave?: (template: ReportTemplate) => void;
-    /** Absent hides the Close button. */
     onCancel?: () => void;
-    /** Reflects every change, for a caller that wants to persist a draft. */
     onChange?: (template: ReportTemplate) => void;
-    /** Shown in the toolbar. Defaults to the template's name. */
     title?: ReactNode;
 }
 export declare const ReportDesigner: ({ template: initial, registry, context, onSave, onCancel, onChange, title, }: ReportDesignerProps) => import("react").JSX.Element;

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

@@ -1,10 +1,2 @@
 import type { TableEditorProps } from './types';
-/**
- * A table's settings, in three tabs.
- *
- * All seven sections at once came to nearly eight screens of scrolling for one table, which is not
- * a form anyone reads — the question "where do the rows come from" sat six screens above the answer
- * to "why is this column empty". They are grouped the way a report is built: the data first, then
- * the columns that show it, then how the whole thing is laid out on the page.
- */
 export declare const TableEditor: (props: TableEditorProps) => import("react").JSX.Element;

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

@@ -1,6 +1,5 @@
 import type { ChipSources, ReportRegistry, TableBlock, TemplateOption } from '../../../published/dcs-ui/src/publicTypes';
 import { type FieldOption, type FieldPlace } from '../../../published/dcs-ui/src/publicLogic';
 export declare const chipSourcesFromFields: (fields: FieldOption[]) => ChipSources;
-/** Chips for one place in a template — a column value, a group line, a closing row, a page band. */
 export declare const chipSourcesFor: (registry: ReportRegistry, place: FieldPlace, table?: Pick<TableBlock, "data">, templateOptions?: TemplateOption[]) => ChipSources;
 export declare const useChipSources: (registry: ReportRegistry, place: FieldPlace, table?: Pick<TableBlock, "data">, templateOptions?: TemplateOption[]) => ChipSources;

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

@@ -1,12 +1,7 @@
 import type { ReactNode } from 'react';
 import type { Band, BandKind, Block, ReportRegistry, TextCell, TextRow } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * How the designer names things — always in the author's terms ("Top of every page"), never the
- * model's (`pageHeader`).
- */
 export declare const BAND_LABELS: Record<BandKind, string>;
 export declare const BAND_HINTS: Record<BandKind, string>;
-/** Offered in print order, so the menu reads the way the document does. */
 export declare const BAND_KINDS: BandKind[];
 export declare const bandTitle: (band: Band) => string;
 export interface BlockChoice {
@@ -15,20 +10,13 @@ export interface BlockChoice {
     description: string;
     make: () => Omit<Block, 'id'>;
 }
-/**
- * What an author can add to a band. A table is offered once per dataset the app passes, so "Table
- * of Items" and "Table of Tax summary" are one click each, already showing their first fields.
- */
 export declare const blockChoices: (registry: ReportRegistry) => BlockChoice[];
 export declare const blockTitle: (block: Block) => string;
-/** One line saying what the block holds, for the tree and a band's contents. */
 export declare const blockSummary: (block: Block, registry?: ReportRegistry) => string;
-/** The text a row or a column of a text block prints, for naming it in a crumb or a list. */
 export declare const textOfCell: (cell: TextCell) => string;
 export declare const textRowTitle: (row: TextRow, index: number) => string;
 export declare const textRowSummary: (row: TextRow) => string;
 export declare const textCellTitle: (cell: TextCell, index: number) => string;
 export declare const textCellSummary: (cell: TextCell) => string;
 export declare const blockIcon: (block: Block) => ReactNode;
-/** Joins class names, dropping the ones a condition switched off. */
 export declare const cx: (...names: Array<string | false | null | undefined>) => string;

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

@@ -1,9 +1,5 @@
 import { type ReactNode } from 'react';
 import type { FieldSetProps } from './types';
-/**
- * Quoin designer — the pieces every inspector panel is laid out with, so every panel reads alike:
- * a sticky header naming what is selected, then titled sections.
- */
 export declare const Section: ({ title, action, children }: {
     title: string;
     action?: ReactNode;
@@ -13,7 +9,6 @@ export declare const Header: ({ title, hint, back, path }: {
     title: string;
     hint?: string;
     back?: ReactNode;
-    /** Where this thing sits, root first. Each crumb goes there. */
     path?: ReactNode;
 }) => import("react").JSX.Element;
 export interface Crumb {
@@ -21,29 +16,12 @@ export interface Crumb {
     label: string;
     onClick: () => void;
 }
-/**
- * Where you are, and the way back to anywhere above it.
- *
- * A single "back" button only answers "what is my parent", one step at a time, and says nothing
- * about how deep you are — go band › table › column and the panel is titled "Column", with the
- * band four levels up unnamed. Every crumb here is a destination, so no level is more than one
- * click away from any other.
- */
 export declare const Path: ({ crumbs }: {
     crumbs: Crumb[];
 }) => import("react").JSX.Element | null;
-/** A short explanation under a control. */
 export declare const Hint: ({ children }: {
     children: ReactNode;
 }) => import("react").JSX.Element;
-/**
- * One thing in a list, which opens when clicked.
- *
- * The designer had three of these written by hand — a band's contents, a table's columns, a text
- * block's rows — each with its own markup, its own actions and its own idea of whether clicking it
- * did anything. They are the same gesture: "this is one of several; open it". Opening a thing
- * rather than expanding it in place is what keeps a panel one level deep.
- */
 export declare const DrillRow: ({ icon, title, summary, badges, actions, onOpen }: {
     icon?: ReactNode;
     title: string;
@@ -52,12 +30,4 @@ export declare const DrillRow: ({ icon, title, summary, badges, actions, onOpen
     actions?: ReactNode;
     onOpen: () => void;
 }) => import("react").JSX.Element;
-/**
- * A set of field keys, chosen.
- *
- * Drawn as what IS chosen, with the choosing behind a button. A checkbox per field is fine for six
- * or eight; the invoice item data has sixty-one, which filled a third of the panel with boxes nobody
- * ticks and buried the six that were ticked among them. Here the answer is always on screen and the
- * question is one click away, searchable, and sorted into the registry's own groups.
- */
 export declare const FieldSet: ({ label, hint, fields, selected, onChange }: FieldSetProps) => import("react").JSX.Element;