@dcs-tech/ui 0.2.0 → 0.4.0

package/dist/types/shared-logic/src/ui/fieldControl.logic.d.ts

@@ -1,24 +0,0 @@
-export interface FieldControlClassOptions {
-    /** FieldSize: 'xxs' | 'xs' | 'small' | 'medium' | 'large' | 'xl' */
-    size?: string;
-    /** FieldVariant: 'outlined' | 'filled' | 'standard' | 'underlined' */
-    variant?: string;
-    error?: boolean;
-    disabled?: boolean;
-    readOnly?: boolean;
-    /** Reserve trailing space for in-field affixes (select arrow, clear button, …). */
-    hasAffix?: boolean;
-    /**
-     * A joined popup is open beneath this control, so its bottom corners must square to meet
-     * the list. Ignored for variants with no box — those get a floating panel instead.
-     */
-    popupOpen?: boolean;
-}
-/**
- * Class keys for the shared control surface used by Input, Select and Suggest.
- *
- * All three map these keys against the SAME CSS module
- * (shared-web-ui/src/styles/fieldControl.module.css), so a given size/variant
- * resolves to one identical set of rules regardless of which control renders it.
- */
-export declare const buildFieldControlClassKeys: ({ size, variant, error, disabled, readOnly, hasAffix, popupOpen, }: FieldControlClassOptions) => string[];

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

@@ -1,55 +0,0 @@
-/**
- * The UI half of `shared-logic`, on its own.
- *
- * WHY THIS FILE EXISTS — it is a privacy boundary, not a convenience.
- *
- * The package barrel (`shared-logic/src/index.ts`) re-exports this folder AND every domain
- * folder beside it. Anything that imports the barrel therefore pulls the whole package into
- * its TypeScript program — and `tsc` emits declarations for a whole program, not for the
- * subset a barrel happens to re-export.
- *
- * That is how `@dcs-tech/ui@0.1.0` shipped this business's domain type surface to the public
- * npm registry (audited 2026-09-28): the JS bundle was clean, because a bundler tree-shakes,
- * but the emitted `dist/types/` carried the domain declarations — signatures, field names and
- * doc comments. The `export *` gate in `dcs-ui/src/index.ts` guards the JS surface only; it
- * never governed the declaration emit.
- *
- * (This comment names no domain folder on purpose: it ships, as the leak it describes proves.)
- *
- * So the published build maps `@pdfinvoice/shared-logic` to this file instead, and the domain
- * never enters the program. Keep it that way:
- *
- *   - ONLY `./ui/*` modules belong here. Never add a domain module, however small, and never
- *     re-export the parent barrel.
- *   - A UI module that starts importing domain code re-opens the hole silently — the guard in
- *     `dcs-ui` (`npm run verify:no-leak`) is what catches it.
- *
- * It is also the import the API should use. `apps/api` must never touch the package barrel:
- * that pulls React in through `useMergeRefs` and kills every Cloud Run function at startup.
- */
-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 './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 './navigation.logic';
-export * from './popover.logic';
-export * from './popupList.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 './useMergeRefs';

package/dist/types/shared-logic/src/ui/keyboard.logic.d.ts

@@ -1,72 +0,0 @@
-import type { FieldKeyboardConfig, KeyEventLike, KeyResolution, KeyResolutionContext, NavAction } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * The one place that decides who owns a key.
- *
- * Pure, and deliberately free of React and the DOM: it takes a `KeyEventLike`
- * (which a `React.KeyboardEvent` satisfies structurally) and returns a verdict.
- * That is what lets the whole truth table run under plain `node`, and what keeps
- * it mechanically portable to the mobile core package if mobile ever grows a grid.
- *
- * ── The two laws ────────────────────────────────────────────────────────────
- *
- * **L1** — in `navigate` mode the container owns every arrow, Enter, Tab,
- * Home/End and PageUp/Down.
- *
- * **L2** — an open popup owns ↑ ↓ Enter Escape for as long as it is open,
- * whichever widget opened it and whatever mode the cell is in.
- *
- * Everything below is a consequence of those two. L2 is checked before L1
- * because it is the narrower claim: a Select with its list down is not "a cell
- * being navigated", it is a list being navigated, and the grid must not see
- * those keys at all.
- */
-/**
- * Canonical form: modifiers alphabetically, then the key, all lower-case —
- * `alt+ctrl+shift+enter`. Sorting is what makes `'ctrl+shift+enter'` and
- * `'shift+ctrl+enter'` the same binding, so a consumer cannot write an override
- * that silently never matches because they ordered the modifiers differently.
- */
-export declare function parseBinding(binding: string): string;
-/** The canonical binding string an event represents. */
-export declare function eventBinding(event: KeyEventLike): string;
-export declare function matchBinding(event: KeyEventLike, binding: string): boolean;
-/**
- * The container bindings a grid starts with.
- *
- * The `ctrl+arrow*` and `alt+arrow*` entries are **aliases kept on purpose**.
- * They are what the current editable table binds, because Input owned no keys
- * and plain arrows never reached the grid. Keeping them means existing screens
- * and existing muscle memory survive the switch to plain arrows instead of
- * breaking on the day the new grid lands.
- */
-export declare const DEFAULT_GRID_BINDINGS: Record<string, NavAction>;
-/** A form is a one-column grid: no rows to add, and Ctrl+Enter submits. */
-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'>>;
-/** What a cell wants when nothing overrides it: grid mode, Enter moves on, type to open. */
-export declare const GRID_CELL_KEYBOARD_DEFAULTS: FieldKeyboardConfig;
-/**
- * A key that produces a character. `metaKey`/`ctrlKey` exclude shortcuts;
- * `altKey` is *not* excluded because AltGr (which reports `ctrlKey && altKey`)
- * is how a great many non-US layouts type ordinary characters.
- */
-export declare function isPrintableKey(event: KeyEventLike): boolean;
-export declare function resolveFieldKey(event: KeyEventLike, ctx: KeyResolutionContext): KeyResolution;
-/**
- * The next index in a linear list, skipping the ones a predicate rejects.
- *
- * A form is a one-column grid, so this is the one-dimensional sibling of
- * `findNextFocusableCell`. Kept pure and separate from any DOM query: what
- * counts as "focusable" is the caller's business, and this way the traversal is
- * testable without a browser.
- *
- * @returns the next usable index, or `-1` when the list runs out.
- */
-export declare function nextFocusableIndex(count: number, current: number, direction: 'forward' | 'backward', isDisabled?: (index: number) => boolean, wrap?: boolean): number;
-/**
- * Resolves the config a field actually runs on: own prop → container → default.
- *
- * The same order `useFieldSurface` uses for `size`, and for the same reason — a
- * field must be able to tell "nobody said" from "someone said grid mode".
- */
-export declare function resolveKeyboardConfig(own: FieldKeyboardConfig | undefined, inherited: FieldKeyboardConfig | undefined): FieldKeyboardConfig;

package/dist/types/shared-logic/src/ui/navigation.logic.d.ts

@@ -1,30 +0,0 @@
-import type { NavItem } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * Path from the root to the item with `id`, inclusive. `[]` when not found.
- *
- * This one function serves both surfaces, which is the point of a single `NavItem` shape:
- * a **Sidebar highlights** the trail (every ancestor of the active row reads as active), and
- * **Breadcrumbs render** it. Computing "where am I" twice, in two components, is how the two
- * end up disagreeing about it.
- */
-export declare function findNavTrail(items: NavItem[], id: string | null | undefined): NavItem[];
-/** Depth-first list of every item, groups included. */
-export declare function flattenNav(items: NavItem[]): NavItem[];
-/**
- * Drop items a predicate rejects, pruning branches bottom-up.
- *
- * A parent whose children are ALL removed is removed too — unless it is reachable in its own
- * right (it has an `href` or is a `group`). Otherwise a permission filter leaves behind
- * headings that expand to nothing.
- */
-export declare function filterNav(items: NavItem[], keep: (item: NavItem) => boolean): NavItem[];
-/** The ids on the trail to `activeId`, for "is this row on the active path" checks. */
-export declare function navTrailIds(items: NavItem[], activeId: string | null | undefined): Set<string>;
-/**
- * The item whose `href` best matches a pathname — longest match wins, so
- * `/reports/monthly/sales` prefers that over `/reports`.
- *
- * For apps that track location rather than an id. Returns null when nothing matches; callers
- * that know their active id should pass it directly instead.
- */
-export declare function findNavItemByPath(items: NavItem[], pathname: string): NavItem | null;

package/dist/types/shared-logic/src/ui/popover.logic.d.ts

@@ -1,57 +0,0 @@
-export type PopoverSide = 'top' | 'bottom' | 'left' | 'right';
-export type PopoverAlign = 'start' | 'center' | 'end';
-/** `side` plus optional alignment, e.g. `bottom-start`. Bare `bottom` means `bottom-center`. */
-export type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
-export interface PopoverRect {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-}
-export interface ComputePopoverPositionInput {
-    /** Trigger box in VIEWPORT coordinates — i.e. straight from getBoundingClientRect(). */
-    anchor: PopoverRect;
-    /** Measured content box. Pass zeroes on the first pass; re-run once it is measured. */
-    content: {
-        width: number;
-        height: number;
-    };
-    viewport: {
-        width: number;
-        height: number;
-    };
-    /** Page scroll, added to the result so the caller can position in DOCUMENT coordinates. */
-    scroll: {
-        x: number;
-        y: number;
-    };
-    placement?: PopoverPlacement;
-    /** Gap between anchor and content, px. Default 4. */
-    offset?: number;
-    /** Force the content to the anchor's width (what a Select dropdown wants). */
-    matchAnchorWidth?: boolean;
-    /** Flip to the opposite side when the preferred one doesn't fit. Default true. */
-    flip?: boolean;
-    /** Slide along the cross axis to stay on screen. Default true. */
-    shift?: boolean;
-    /** Minimum gap from the viewport edge, px. Default 8. */
-    padding?: number;
-}
-export interface PopoverPosition {
-    /** DOCUMENT coordinates — scroll already added. */
-    top: number;
-    left: number;
-    /** Only set when `matchAnchorWidth`. */
-    width?: number;
-    /** Where it actually ended up, which may differ from the request after a flip. */
-    placement: PopoverPlacement;
-    /** True when `flip` changed the side. Useful for pointing an arrow the right way. */
-    flipped: boolean;
-}
-/**
- * Where to put a floating box relative to its anchor.
- *
- * Returns DOCUMENT coordinates (viewport rect + scroll), because a portalled layer is
- * positioned absolutely against the page, not the viewport.
- */
-export declare function computePopoverPosition(input: ComputePopoverPositionInput): PopoverPosition;

package/dist/types/shared-logic/src/ui/popupList.logic.d.ts

@@ -1,54 +0,0 @@
-import type { FieldSize, FieldVariant, SelectOption, GroupConfig } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * Class keys for the shared option-list surface (styles/popupList.module.css),
- * used by both Select's dropdown and Suggest's suggestion list.
- */
-export interface PopupListClassOptions {
-    size: FieldSize;
-    variant: FieldVariant;
-}
-/**
- * The popup takes its shape from the field it hangs off:
- *
- * - `outlined` / `filled` have a box, so the list **joins** it — no top border,
- *   square top corners, flush against the field's lower edge.
- * - `standard` / `underlined` have only a rule under the text, so a box glued to
- *   that edge reads as a mistake. Those get a **floating** panel instead: closed
- *   border, all corners rounded, sitting just below the underline.
- */
-/**
- * Does this variant's field have a box the popup can continue?
- *
- * Exported because BOTH sides of the joint need the same answer: the list squares its top
- * (here) and the control squares its bottom (buildFieldControlClassKeys). Deciding it twice is
- * how you get a rounded control meeting a square list.
- */
-export declare const isJoinedPopupVariant: (variant: string | undefined) => boolean;
-export declare function buildPopupListClassKeys(opts: PopupListClassOptions): string[];
-export interface PopupRowClassOptions {
-    /** The keyboard/hover cursor is on this row. Neutral fill. */
-    isCursor?: boolean;
-    /** This row is the current value. Accent tint + tick. */
-    isSelected?: boolean;
-    isDisabled?: boolean;
-    /** Multi-select rows carry a checkbox, so the tick is suppressed. */
-    isMulti?: boolean;
-}
-export declare function buildPopupRowClassKeys(opts: PopupRowClassOptions): string[];
-/** One rendered group: its heading and the options under it. */
-export interface OptionGroup {
-    name: string;
-    options: SelectOption[];
-}
-/**
- * Splits options into ordered groups for a grouped list.
- *
- * Order: `groupOrder` if given (array = explicit order, function = comparator),
- * otherwise first-appearance order, which keeps a hand-written options array
- * rendering in the order it was written. Options with no group are emitted first
- * under an empty name so the caller can render them without a heading.
- *
- * Returns a single unnamed group when grouping is off, so callers have one shape
- * to render either way.
- */
-export declare function groupSelectOptions(options: SelectOption[], config?: GroupConfig): OptionGroup[];

package/dist/types/shared-logic/src/ui/select.logic.d.ts

@@ -1,31 +0,0 @@
-import { SelectOption, SortConfig, SearchConfig } from '../../../published/dcs-ui/src/publicTypes';
-interface SelectClassOpts {
-    size: string;
-    isOpen?: boolean;
-    disabled?: boolean;
-    error?: boolean;
-    isInModal?: boolean;
-}
-export declare function buildSelectClassKeys(opts: SelectClassOpts): string[];
-export declare function normalizeSelectOptions(options: (string | number | SelectOption)[]): SelectOption[];
-export declare function sortSelectOptions(options: SelectOption[], sortConfig?: boolean | SortConfig): SelectOption[];
-export declare function filterSelectOptions(options: SelectOption[], searchTerm: string, searchConfig?: boolean | SearchConfig): SelectOption[];
-/**
- * Type-ahead for a closed or open Select: the index of the next option whose label
- * starts with `query`, searching forward from `fromIndex` and wrapping.
- *
- * Spec (FIELD_KEYBOARD_NAVIGATION.md §6.4): a printable key on a Select jumps to the
- * matching option. An operator entering sizes types `M`, not ↓↓↓. Starting AFTER
- * `fromIndex` is what makes a repeated letter cycle — `S`, `S` walks Small → S-Slim.
- *
- * Case-insensitive, disabled options skipped. Single-character cycling only: a
- * multi-key buffer ("me" typed quickly) needs a timer, and a timer-driven buffer is
- * exactly what throttles unpredictably in a background tab.
- *
- * @returns the matching index, or -1 when nothing matches.
- */
-export declare function findTypeaheadIndex(options: Array<{
-    name: string | number;
-    disabled?: boolean;
-}>, query: string, fromIndex: number): number;
-export {};

package/dist/types/shared-logic/src/ui/tableLayout.logic.d.ts

@@ -1,47 +0,0 @@
-import type { ColumnAlign, EditableTableColumnDefinition, ResolvedColumnLayout, ResolvedTableLayout } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * Column layout, decided once and purely.
- *
- * The client editable table has no layout props at all, so every column in the
- * Program table renders at exactly 300px — a 2700px table in a 1542px
- * container, Qty as wide as Notes. This resolves each column's frame from its
- * props, and where a column names none, from a default for the kind of field it
- * holds. **Prop → default**, the same order `size` and `keyboard` resolve in.
- */
-/** What a column holds, as far as layout is concerned. */
-export type ColumnWidget = 'suggest' | 'select' | 'number' | 'derivedNumber' | 'date' | 'text' | 'derivedText' | 'toggle' | 'button' | 'other';
-interface ColumnDefault {
-    /** Present = fixed width. Absent = flexible, sharing the remaining space. */
-    width?: number;
-    minWidth: number;
-    align: ColumnAlign;
-}
-/**
- * The defaults by widget. Tuned against a real production program table's columns:
- * an item name needs room to be read, a quantity does not.
- */
-export declare const COLUMN_LAYOUT_DEFAULTS: Readonly<Record<ColumnWidget, ColumnDefault>>;
-export declare function classifyColumn(column: EditableTableColumnDefinition<any>): ColumnWidget;
-/**
- * One column's frame.
- *
- * - An explicit `width` makes the column fixed, and a fixed column's floor IS its
- *   width — a `minWidth` beside a `width` has nothing left to decide.
- * - A **sticky** column is always fixed. Pinned columns stack by offset, and an
- *   offset can only be exact if every pinned width is known; a flexible pinned
- *   column would push the next one to the wrong place. Unsized, it pins at its
- *   floor.
- */
-export declare function resolveColumnLayout(column: EditableTableColumnDefinition<any>): ResolvedColumnLayout;
-/**
- * Every column's frame, plus the pinned-column offsets and the table's floor.
- *
- * Pinned columns stay pinned in the order they appear: left-pinned offsets
- * accumulate left to right, right-pinned offsets right to left. The innermost
- * pinned column on each side is its `stickyEdge`, which is where scrolling
- * content passes under and a divider belongs.
- */
-export declare function resolveTableLayout(columns: EditableTableColumnDefinition<any>[]): ResolvedTableLayout;
-/** A read-only cell renders text instead of a field — and the keyboard skips it. */
-export declare function isReadOnlyColumn(column: EditableTableColumnDefinition<any>): boolean;
-export {};

package/dist/types/shared-logic/src/ui/tooltip.logic.d.ts

@@ -1,35 +0,0 @@
-import type { TooltipAnchorTo, TooltipConfig, TooltipPlacement, TooltipPosition, TooltipPositionInput, TooltipProp } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * A `tooltip` prop is either bare content or a config object. Anything that is
- * a React element counts as content — only a plain object carrying `content`
- * is treated as configuration.
- */
-export declare function normalizeTooltip(value: TooltipProp | undefined): TooltipConfig | null;
-export interface TooltipAnchorDecision {
-    anchorTo: TooltipAnchorTo;
-    /** Keyboard focus has no cursor, so it can never be pointer-anchored. */
-    openedBy: 'pointer' | 'focus';
-    anchorWidth: number;
-    tooltipWidth: number;
-}
-/**
- * Whether to place the tooltip at the cursor rather than against the trigger.
- *
- * The `auto` rule: element-anchoring only reads as "attached to this thing" while
- * the trigger is no wider than the tip. Past that — block text, a table row, a
- * full-width header — the tip centres on the element and lands far from where the
- * pointer actually is, so it follows the pointer instead.
- */
-export declare function shouldAnchorToPointer(decision: TooltipAnchorDecision): boolean;
-/** Requested placement first, then its opposite, then the perpendicular pair. */
-export declare function resolveTooltipPlacementOrder(placement: TooltipPlacement): TooltipPlacement[];
-/**
- * Viewport-coordinate position for a tooltip, flipping to the first placement
- * that fits and then clamping along the cross axis so it never leaves the
- * screen. Pure geometry — the caller measures the DOM and applies the result.
- *
- * Only the fallback path for browsers without CSS anchor positioning uses this;
- * where anchor positioning is supported the same behaviour comes from
- * `position-try-fallbacks`.
- */
-export declare function computeTooltipPosition(input: TooltipPositionInput): TooltipPosition;

package/dist/types/shared-logic/src/ui/useMergeRefs.d.ts

@@ -1,10 +0,0 @@
-import type { Ref, RefCallback } from 'react';
-/**
- * Merge several refs into one stable ref callback.
- *
- * The callback identity never changes, which matters: memoising on the spread
- * `refs` array instead produces a new callback on every render, and React
- * responds by calling the old callback with `null` and the new one with the
- * node — detaching and re-attaching the ref on every single render.
- */
-export declare function useMergeRefs<T>(...refs: (Ref<T> | undefined | null)[]): RefCallback<T>;

package/dist/types/shared-types/src/report/bands.d.ts

@@ -1,32 +0,0 @@
-/**
- * Report engine — bands, the sections of a page.
- *
- * Three kinds, and the order of `template.bands` is the print order:
- *
- * - `pageHeader` — the top of every page.
- * - `content` — prints once, where it stands. Tables inside it flow across pages.
- * - `pageFooter` — the foot of every page.
- *
- * v1 also had detail, group and report header/footer bands. They existed to serve the one main
- * grid; a table now carries its own rows, sections and closing rows, and "report header" is simply
- * the first content band. See `docs/REPORT_ENGINE.md` §14.3.
- */
-import type { Block } from './blocks';
-import type { ReportConditionGroup } from './conditions';
-export type BandKind = 'pageHeader' | 'content' | 'pageFooter';
-export interface Band {
-    id: string;
-    kind: BandKind;
-    /**
-     * For `content`: print it on every page, under the page header — the business and buyer block
-     * that several invoice formats repeat. Ignored for page bands, which repeat by definition.
-     */
-    repeatOnEveryPage?: boolean;
-    /** Never split this band across a page break; move it whole to the next page instead. */
-    keepTogether?: boolean;
-    /** Never end a page with this band: if the band after it moves on, this band moves with it. */
-    keepWithNext?: boolean;
-    /** Suppress the band entirely when this fails. */
-    condition?: ReportConditionGroup;
-    blocks: Block[];
-}

package/dist/types/shared-types/src/report/blocks.d.ts

@@ -1,181 +0,0 @@
-/**
- * Report engine — blocks, the things a band is made of.
- *
- * A table is a block like any other and can go anywhere, as many times as a report needs. There is
- * no special "main grid": everything v1 did for it — a heading on every page, a closed box, empty
- * rows down the page, closing rows kept with what follows — belongs to every table that flows.
- * See `docs/REPORT_ENGINE.md` §14.4.
- */
-import type { ReportConditionGroup } from './conditions';
-import type { ColumnSpec, TableData } from './dataset';
-import type { GridFill, GridLines } from './template';
-import type { Alignment, PlaceholderFormat, PlaceholderFormats, StrokeStyle, TextSegment, TextStyle } from './primitives';
-export interface BlockBase {
-    id: string;
-    condition?: ReportConditionGroup;
-    style?: TextStyle;
-    /** Points, [top, right, bottom, left]. A negative side widens the block into the page margin. */
-    margin?: [number, number, number, number];
-}
-/** An image at the left of a cell, the text beside it — a logo before the business name. */
-export interface CellImage {
-    /** A URL or data URI, or a placeholder resolving to one. Empty draws no image. */
-    src: string;
-    widthPt: number;
-    heightPt: number;
-    /** Space between the image and the text. */
-    gapPt?: number;
-}
-/** One cell of a text block's row. Width is a percentage of the block, or 'auto'. */
-export interface TextCell {
-    id: string;
-    width: number | 'auto';
-    align?: Alignment;
-    style?: TextStyle;
-    segments: TextSegment[];
-    condition?: ReportConditionGroup;
-    /** A fixed width in points, overriding `width`; the other cells share what is left. */
-    widthPt?: number;
-    image?: CellImage;
-}
-export interface TextRow {
-    id: string;
-    cells: TextCell[];
-    condition?: ReportConditionGroup;
-    /**
-     * The row is at least this tall, points, padding included and lines excluded — room left for a
-     * signature, or a box that must not collapse when its fields are empty.
-     */
-    minHeightPt?: number;
-    /** A line above this row when it sits inside a box — the rule over a total. */
-    lineAbovePt?: number;
-}
-/**
- * One cell of a column-aligned row, covering the columns `from` through `to`, by column id.
- *
- * On a `groupColumns` column (with no `to`, or `to` the same column) the cell repeats once per
- * generated column, with that value's `%group.*%` in scope — a total under every size.
- */
-export interface AlignedCell {
-    id: string;
-    from: string;
-    /** Absent covers `from` alone. */
-    to?: string;
-    segments: TextSegment[];
-    align?: Alignment;
-    style?: TextStyle;
-    /** Format for every placeholder in the cell that has none of its own. */
-    format?: PlaceholderFormat;
-}
-/**
- * A row laid out on a table's own columns rather than by percentages, so a figure sits exactly
- * under its column — a tax amount under Amount, "Total" spanning everything before it. A column no
- * cell covers prints empty, with its column lines. Cells name columns by id, which keeps them right
- * when a column is hidden by a condition or expanded per group value.
- */
-export interface AlignedRow {
-    id: string;
-    cells: AlignedCell[];
-    condition?: ReportConditionGroup;
-    minHeightPt?: number;
-    /** A line above this row — the rule over a grand total. */
-    lineAbovePt?: number;
-}
-/** A heading above several column headings — "Central Tax" over Rate | Amount, "Sizes" over the size columns. */
-export interface HeaderGroup {
-    id: string;
-    label: string;
-    from: string;
-    to: string;
-    style?: TextStyle;
-}
-export interface TextBlock extends BlockBase {
-    type: 'text';
-    rows: TextRow[];
-    /**
-     * Draws the block as a box: `outer` around it, `columns` between cells, `rows` between rows.
-     * `header` is unused here. These take space and are planned with.
-     */
-    lines?: GridLines;
-}
-export interface TableHeader {
-    /** Default true. */
-    show?: boolean;
-    /** Print the heading again at the top of every page the table continues onto. Default true. */
-    repeat?: boolean;
-    style?: TextStyle;
-    /** A heading row above the column headings, each label spanning the columns it groups. */
-    groups?: HeaderGroup[];
-}
-/**
- * Rows split into sections each time `by` changes — a category heading, an ageing bucket with its
- * subtotal. Not the same thing as grouping values (`TableData.group`), and named apart for that.
- */
-export interface SectionSpec {
-    by: string;
-    sort?: 'asc' | 'desc';
-    /** Printed above each section. `%row.*%` is its first row; `%agg.*(row.x)%` covers the section. */
-    header?: AlignedRow[];
-    /** Printed below each section, with the same scope. */
-    footer?: AlignedRow[];
-    /** Try to keep a section on one page. */
-    keepTogether?: boolean;
-}
-export interface TableBlock extends BlockBase {
-    type: 'table';
-    data: TableData;
-    columns: ColumnSpec[];
-    header?: TableHeader;
-    sections?: SectionSpec;
-    /** Rows closing the table after its last row — tax, round off, total — under their columns. */
-    footer?: AlignedRow[];
-    /** Keep the closing rows on the page with whatever follows the table. */
-    footerKeepWithNext?: boolean;
-    /** Ruling — box, between columns, under the heading, between rows. */
-    lines?: GridLines;
-    /** Empty rows under the last row, so the box runs down the page. */
-    fill?: GridFill;
-    /**
-     * true: the table moves to the next page whole rather than splitting — a small summary.
-     * false (default): it flows across pages, row by row, its heading repeating.
-     */
-    keepTogether?: boolean;
-}
-export interface ImageBlock extends BlockBase {
-    type: 'image';
-    /** Literal URL/data-URI, or a placeholder resolving to one. */
-    src: string;
-    widthPt: number;
-    heightPt?: number | 'auto';
-    align?: Alignment;
-}
-export interface BarcodeBlock extends BlockBase {
-    type: 'barcode';
-    content: string;
-    formats?: PlaceholderFormats;
-    symbology: 'CODE128' | 'CODE39' | 'EAN13' | 'EAN8' | 'UPC' | 'ITF14';
-    showValue?: boolean;
-    barWidth?: number;
-    heightPt: number;
-    align?: Alignment;
-}
-export interface QRBlock extends BlockBase {
-    type: 'qr';
-    content: string;
-    formats?: PlaceholderFormats;
-    sizePt: number;
-    errorCorrection?: 'L' | 'M' | 'Q' | 'H';
-    align?: Alignment;
-}
-export interface SeparatorBlock extends BlockBase {
-    type: 'separator';
-    stroke: StrokeStyle;
-    thicknessPt?: number;
-}
-/** Vertical whitespace — a signature gap, a spacer above totals. */
-export interface SpacerBlock extends BlockBase {
-    type: 'spacer';
-    heightPt: number;
-}
-export type Block = TextBlock | TableBlock | ImageBlock | BarcodeBlock | QRBlock | SeparatorBlock | SpacerBlock;
-export type BlockType = Block['type'];

package/dist/types/shared-types/src/report/conditions.d.ts

@@ -1,24 +0,0 @@
-/**
- * Report engine — conditional visibility.
- *
- * Prefixed `Report*` because `ui/fields.types.ts` already exports a `ConditionOperator` — a
- * different thing (form-field visibility, generic over the form's own shape) that happens to
- * share the obvious name.
- *
- * Carried over from `ReceiptDesigner/types.ts` unchanged in meaning: the operator set was arrived
- * at by use and there is no reason to redesign it. The one change is that the legacy single-rule
- * shape is gone — nothing in production authored one, so the union does not need to survive.
- */
-export type ReportConditionOperator = '==' | '!=' | '>' | '>=' | '<' | '<=' | 'contains' | 'startsWith' | 'in' | 'notIn' | 'exists' | 'notExists';
-export interface ReportConditionRule {
-    id: string;
-    /** `source.field` or `row.field`, resolved against the registry. */
-    field: string;
-    operator: ReportConditionOperator;
-    /** Omitted for `exists` / `notExists`. */
-    value?: string | number | boolean | Array<string | number>;
-}
-export interface ReportConditionGroup {
-    match: 'all' | 'any';
-    rules: ReportConditionRule[];
-}