@dcs-tech/ui 0.2.0 → 0.3.0

package/dist/summaryChartData-CU_W5ocv.js

@@ -0,0 +1,82 @@
+"use client";
+import { At as e, J as t } from "./ChartImageMenu-gvNAYVkY.js";
+//#region ../../shared-web-ui/src/DataTable/summary/summaryChartData.ts
+function n(e, t) {
+	return {
+		type: "values",
+		values: t.map((t) => ({
+			key: t.key,
+			label: t.label,
+			count: t.count,
+			...t.others ? {
+				slot: "rest",
+				selectable: !1
+			} : e.card.slots?.[t.key] === void 0 ? {} : { slot: t.slot },
+			...t.children ? { children: t.children.map((e) => ({
+				key: e.key,
+				label: e.label,
+				count: e.count
+			})) } : {}
+		}))
+	};
+}
+function r(e) {
+	switch (e.kind) {
+		case "unavailable": return {
+			type: "number",
+			value: 0
+		};
+		case "value": return {
+			type: "number",
+			value: e.value ?? 0,
+			...e.trend ? {
+				points: e.trend.points.map((e) => ({
+					key: e.key,
+					label: e.fullLabel,
+					value: e.count
+				})),
+				previous: e.trend.previous,
+				good: e.card.trend?.good
+			} : {}
+		};
+		case "ratio": return {
+			type: "part",
+			label: e.card.title,
+			value: e.value ?? 0,
+			total: e.total ?? 0,
+			color: e.card.color
+		};
+		case "trend": {
+			let t = e.periods ?? [], n = e.series.length > 0;
+			return {
+				type: "time",
+				period: e.card.period,
+				...n ? { series: e.series.map((e) => ({
+					key: e.key,
+					label: e.label,
+					slot: e.slot
+				})) } : {},
+				points: t.map((e) => ({
+					key: e.key,
+					label: e.label,
+					fullLabel: e.fullLabel,
+					...n ? { counts: e.split ?? {} } : { count: e.count }
+				}))
+			};
+		}
+		case "funnel": return {
+			type: "steps",
+			steps: (e.steps ?? []).map((e) => ({
+				key: e.key,
+				label: e.label,
+				count: e.count,
+				slot: e.slot,
+				selectable: e.selectable
+			}))
+		};
+		case "breakdown": return n(e, e.buckets ?? []);
+	}
+}
+var i = (t) => e(t.card), a = (e, n) => t(r(e), i(e), n);
+//#endregion
+export { a as n, i as r, n as t };

package/dist/types/published/dcs-ui/src/index.d.ts

@@ -1,31 +1,3 @@
-/**
- * The public API of @dcs-tech/ui.
- *
- * The reference above is load-bearing: the declaration bundler builds its program
- * from this entry file alone, ignoring tsconfig `include`, so without it the
- * ambient `*.module.css` declaration is missing and every component that imports
- * a stylesheet fails with TS2307.
- *
- * This barrel IS the published surface. Nothing reaches the registry unless it is
- * re-exported here, which is why the library can live in a monorepo alongside
- * private business code without leaking any of it.
- *
- * TWO KINDS OF LINE BELOW, and the difference matters:
- *
- *   `export *` from shared-web-ui
- *       Automatic. That package is components-only — it imports UI types and
- *       nothing else — so a new component appears in the next release with no
- *       edit here.
- *
- *   Named exports from shared-logic
- *       Deliberate. Those packages also contain this business's own domain, so
- *       exporting by name is the gate that keeps it private. NEVER turn these
- *       into `export *`.
- *
- * And note what this barrel does NOT govern: `tsc` emits declarations for the whole
- * program, so it never controlled `dist/types/`. That is what `src/publicLogic.ts` and
- * `src/publicTypes.ts` are for, and what `verify:no-leak` checks.
- */
 export * from '../../../shared-web-ui/src';
 export { buildFieldControlClassKeys, buildPopupListClassKeys, buildPopupRowClassKeys, computeTooltipPosition, normalizeTooltip, resolveTooltipPlacementOrder, shouldAnchorToPointer, useMergeRefs, } from './publicLogic';
 export type { FieldControlClassOptions, PopupListClassOptions, PopupRowClassOptions, TooltipAnchorDecision, } from './publicLogic';

package/dist/types/published/dcs-ui/src/publicLogic.d.ts

@@ -1,35 +1,2 @@
-/**
- * What `@pdfinvoice/shared-logic` means INSIDE the published build.
- *
- * `tsconfig.json` maps the package specifier to this file, so every `from
- * './publicLogic'` in the component sources — 58 of them in `shared-web-ui` alone —
- * resolves here instead of to the package barrel. The domain folders beside `ui/` then never enter the TypeScript program, so no declaration is ever emitted for them.
- *
- * This is the fix for the leak audited on 2026-09-28: `tsc` emits declarations for the whole
- * PROGRAM, so the `export *` gate in `index.ts` — which governs the JS surface, and does govern
- * it correctly — never applied to `dist/types/`. Mapping the specifier is what makes the two
- * surfaces agree.
- *
- * Anything added here ships publicly. The bar: is it generic UI, or is it this business?
- */
 export * from '../../../shared-logic/src/ui';
-/**
- * The report engine, which is deliberately publishable.
- *
- * `ReportDesigner` is a published component and its props are typed in terms of these, so they
- * are part of the public API whether or not they are named here. That is sound: the banded
- * template model was designed DOMAIN-FREE from the start precisely so it could be published —
- * it describes bands, columns and placeholders, not invoices. See `docs/REPORT_ENGINE.md`.
- *
- * `export *` here, unlike the package barrel, and the difference is verified rather than
- * assumed: `report/` imports NO domain sibling at all (checked 2026-09-28 — not one relative
- * import escapes the folder into a business module). It is a closed, generic module, so
- * re-exporting it whole cannot pull the business in behind it.
- *
- * Listing these by name was tried first and is not practical: `ReportDesigner` and
- * `ReportPreview` are published components typed against ~30 of these symbols, so a named list
- * would be a second copy of `report/index` that silently rots whenever an editor gains a
- * prop. The guard that matters is `verify:no-leak`, which fails the build if a domain term
- * ever reaches `dist/` — including through this line, should `report/` stop being closed.
- */
 export * from '../../../shared-logic/src/report/index';

package/dist/types/published/dcs-ui/src/publicTypes.d.ts

@@ -1,14 +1,2 @@
-/**
- * What `@pdfinvoice/shared-types` means INSIDE the published build.
- *
- * The twin of `publicLogic.ts`, for the same reason and by the same mechanism: `tsconfig.json`
- * maps the package specifier here, so the component sources resolve to this instead of to the
- * package barrel — so the folders describing this business's own records never enter the
- * program, or the declarations emitted from it.
- *
- * Both halves are verified self-contained (2026-09-28): neither `shared-types/src/ui` nor
- * `shared-types/src/report` imports a domain sibling, so re-exporting them whole cannot pull
- * the business in behind them. `verify:no-leak` is the standing guard if that ever changes.
- */
 export * from '../../../shared-types/src/ui';
 export * from '../../../shared-types/src/report';

package/dist/types/shared-logic/src/report/aggregate.d.ts

@@ -1,29 +1,8 @@
-/**
- * Report engine — the fixed aggregate set.
- *
- * Eight functions, and deliberately no ninth mechanism. Crystal Reports' expression language is
- * a parser, an editor, a sandbox and a debugger, and it is where projects like this one die.
- * Anything past this list becomes a field the app computes. See `docs/REPORT_ENGINE.md` §7.
- *
- * What an aggregate covers is named in the call itself:
- *   `agg.sum(row.total)`     — the rows of the table or section the text sits in
- *   `agg.sum(group.qty)`     — one group value, across the rows under a group column
- *   `agg.sum(items.total)`   — a whole row set, exactly as the app passed it
- */
 import type { ReportAggregate } from '../../../published/dcs-ui/src/publicTypes';
-/** `%agg.sum(row.total)%` — parsed once so the resolver does not re-parse per row. */
 export interface AggregateCall {
     kind: ReportAggregate;
-    /** `row`, `group`, or a row set key. */
     over: string;
-    /** Path within each row, e.g. `total`. */
     field: string;
 }
-/** Returns null when `expr` is not an aggregate call, so callers can fall through to a path read. */
 export declare const parseAggregate: (expr: string) => AggregateCall | null;
-/**
- * `count` counts rows, not values — a row with a blank total still happened. `distinct` counts the
- * different non-blank values. Every other aggregate ignores rows where the field is absent, so an
- * average is over the rows that have one.
- */
 export declare const computeAggregate: (call: Pick<AggregateCall, "kind" | "field">, rows: Array<Record<string, unknown>>) => number;

package/dist/types/shared-logic/src/report/canvas.d.ts

@@ -1,21 +1,4 @@
-/**
- * Quoin — between the rendered page and the template, for a designer.
- *
- * The HTML renderer tags every band and block it draws with the id it came from. A designer needs
- * two answers from those tags: what did the author just click, and what should be outlined as
- * selected. Both depend on ids the ENGINE mints — a table's repeated heading, one band per table
- * row, a band continued onto the next page, the empty rows filling a page — so the answers live
- * here, beside the constants that mint them, rather than in a React component that would have to
- * know the conventions by heart.
- */
 import type { ReportTemplate } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * What a designer is working on. One thing at a time, which is what makes the inspector simple.
- *
- * EVERY level an author can edit is addressable, down to one column of one row of a text block.
- * A level with no address here can only be reached by opening something inside a panel, which
- * leaves it with no highlight on the page, no place in the tree, and no way back to it.
- */
 export type DesignerSelection = {
     kind: 'page';
 } | {
@@ -44,63 +27,25 @@ export type DesignerSelection = {
     rowId: string;
     cellId: string;
 };
-/** The ids read off the element that was clicked — the nearest tagged band, block and column. */
 export interface CanvasTarget {
     bandId?: string;
     blockId?: string;
     columnId?: string;
 }
-/** One element to outline: `data-<attribute>-id` equal to `value`, or starting with it. */
 export interface CanvasHighlight {
     attribute: 'band' | 'block' | 'column';
     value: string;
     prefix?: boolean;
-    /**
-     * Narrows the match to inside one element. A column id is only unique within its own table, so
-     * a column highlight names the block it belongs to.
-     */
     within?: {
         attribute: 'block';
         value: string;
     };
 }
-/**
- * An engine-minted band id, taken apart: the template band it belongs to, and the piece after the
- * separator — `items:row3`, `items:fill:2`, `part2` — when there is one.
- */
 export declare const parseBandId: (id: string) => {
     bandId: string;
     part?: string;
 };
-/**
- * The selection a click on the page means, or null when it landed on nothing the template owns —
- * the space pagination puts above a page footer, say.
- *
- * A click on any row of a table selects the TABLE: the row exists once in the template but prints
- * once per data row, and what an author means by clicking one is "this table". The block is found by
- * the tagged block id, or failing that by the table id a table's band part starts with.
- */
 export declare const selectionFromCanvas: (template: ReportTemplate, target: CanvasTarget, current?: DesignerSelection) => DesignerSelection | null;
-/**
- * The chain from the document down to a selection, nearest last — what a breadcrumb renders.
- *
- * Structure only: how each step is NAMED belongs to the designer, which speaks the author's
- * language, so nothing here decides wording.
- */
 export declare const selectionAncestors: (template: ReportTemplate, selection: DesignerSelection) => DesignerSelection[];
-/**
- * What to outline for a selection. A band is outlined with every piece of it — the parts around a
- * flowing table, the table's rows, and its continuation onto later pages; a block by the block id,
- * which every row of a flowing table is tagged with.
- *
- * A COLUMN is outlined by its own cells rather than by its table. A table prints one cell per row
- * per column, so the cells of one column are a vertical strip — outlining the whole table for a
- * column selection told an author nothing about which column they had picked.
- */
 export declare const canvasHighlight: (_template: ReportTemplate, selection: DesignerSelection) => CanvasHighlight[];
-/**
- * A selection that still points at something. Removing the selected band, undoing past the block
- * that was selected, or deleting the selected column must not leave the inspector editing a thing
- * that no longer exists — it falls back to the nearest thing that does.
- */
 export declare const liveSelection: (template: ReportTemplate, selection: DesignerSelection) => DesignerSelection;

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

@@ -1,18 +1,4 @@
-/**
- * Report engine — evaluating a condition group.
- *
- * Named `evaluateReportCondition` rather than the obvious `evaluateCondition`, which
- * `ui/fields.logic.ts` already owns for form-field visibility — a different mechanism over a
- * different shape. Matches the `ReportCondition*` types.
- *
- * "Show the business name or not", "print the bank block only when there is a bank", "this column
- * only on GST invoices" — all one mechanism, so none of them is a reason to fork a format.
- */
 import type { ReportConditionGroup, ReportConditionRule } from '../../../published/dcs-ui/src/publicTypes';
 import { type ResolveScope } from './scope';
 export declare const evaluateReportRule: (rule: ReportConditionRule, scope: ResolveScope) => boolean;
-/**
- * A group with no rules is TRUE — an unconfigured condition must not blank the thing it guards.
- * `undefined` is likewise true, so `condition?:` reads as "always, unless told otherwise".
- */
 export declare const evaluateReportCondition: (group: ReportConditionGroup | undefined, scope: ResolveScope) => boolean;

package/dist/types/shared-logic/src/report/constants.d.ts

@@ -1,46 +1,7 @@
-/**
- * Quoin — the report engine's runtime constants.
- *
- * WHY THESE ARE NOT IN `shared-types` BESIDE THEIR TYPES
- *
- * The client resolves `shared-types` to its CommonJS `dist/index.js`, and Vite works out that
- * file's named exports by static analysis. It follows ONE hop of `__exportStar`: that is why
- * `DEFAULT_CONTROL_SIZE` and `UQC_CODES` — re-exported straight from `./ui/control.types` and
- * `./business/uqc.types` — have always worked.
- *
- * The report model has a nested barrel: `index.js` → `report/index.js` → `template.js`. Two hops,
- * and the analysis gives up. Declaring these two constants there took the dev server down with
- * "does not provide an export named 'REPORT_AGGREGATES'" while every type around them was fine,
- * because a type is erased and never asks the loader for anything.
- *
- * Flattening the barrel would also fix it, and would break again the first time someone adds a
- * nested `export *`. Keeping runtime values in `shared-logic` cannot be violated by accident.
- */
-/**
- * Ids the engine mints for things a template never declared — a table's repeated heading, a band
- * continued across a page break, the empty rows that fill a page. Named here, once, because a
- * designer maps a click on the rendered page back to the template by reading them, and a literal
- * copied into two places is a mapping that breaks silently the day one of them changes.
- */
 export declare const CONTINUATION_SUFFIX = ":cont";
-/**
- * Between a template band's id and the piece of it a flowing table produced — `band2/items:row3`.
- * Everything before the first separator is the template band, which is how a click on any row maps
- * back to the band and block it came from.
- */
 export declare const BAND_PART_SEPARATOR = "/";
 export declare const TABLE_HEADER_SUFFIX = ":header";
 export declare const TABLE_FOOTER_SUFFIX = ":footer";
 export declare const TABLE_FILL_INFIX = ":fill";
-/**
- * Bump when a released template shape changes, and add a step to the migration ladder.
- *
- * 2 — tables carry their own data, sections and closing rows; no main grid (`docs/REPORT_ENGINE.md`
- * §14). No step: version 1 was never shipped, and a stored v1 diff falls back to its seed.
- */
 export declare const REPORT_SCHEMA_VERSION = 2;
-/**
- * The fixed aggregate set. There is no expression language and there will not be one; anything
- * beyond this becomes a field the app computes.
- */
 export declare const REPORT_AGGREGATES: readonly ["sum", "count", "avg", "min", "max", "first", "last", "distinct"];

package/dist/types/shared-logic/src/report/dataset.d.ts

@@ -1,21 +1,10 @@
-/**
- * Report engine — the rows one table prints.
- *
- * filter → combine and group → sort, then sections. Pure, and knows nothing about invoices: a
- * group is "the values of a field gathered on a row", a lookup is "a row set that names and orders
- * those values". Which field and which row set is the template's business, and what they mean is
- * the app's. See `docs/REPORT_ENGINE.md` §14.4.
- */
 import type { TableData } from '../../../published/dcs-ui/src/publicTypes';
 import type { GroupScope, ResolveScope } from './scope';
 export type Row = Record<string, unknown>;
-/** One printed row of a table, with the values it gathered when the table groups. */
 export interface TableRow {
     values: Row;
-    /** In display order. Present only when the table groups. */
     groups?: GroupScope[];
 }
-/** A distinct group value across the whole table — one generated column. */
 export interface GroupKey {
     key: string;
     label: string;
@@ -24,26 +13,11 @@ export interface GroupKey {
 }
 export interface BuiltTableRows {
     rows: TableRow[];
-    /** Every group value any row gathered, in display order. Empty when the table does not group. */
     groupKeys: GroupKey[];
 }
-/**
- * The rows a table prints.
- *
- * Combining and grouping happen in one pass: a row joins the combined row it matches on
- * `combine.by`, adding its `combine.sum` fields, and drops its `group.by` value into that row's
- * gathered values, adding `group.sum` fields there. A table that groups but does not combine
- * gathers one value per row — harmless, and what a user building the table step by step sees first.
- */
 export declare const buildTableRows: (data: TableData, rowSets: Record<string, Row[]> | undefined, scope: ResolveScope) => BuiltTableRows;
 export interface TableSection {
-    /** The raw value the section is keyed on. */
     key: unknown;
     rows: TableRow[];
 }
-/**
- * Rows split each time `by` changes. With `sort`, sections are ordered by their key and every row
- * of a key lands in its one section; without, sections follow the rows' order, so a run of the
- * same key after a different one starts a new section — the classic report behaviour.
- */
 export declare const buildSections: (rows: TableRow[], by: string, sort?: "asc" | "desc") => TableSection[];

package/dist/types/shared-logic/src/report/edit.d.ts

@@ -1,78 +1,36 @@
-/**
- * Quoin — editing a template, and being able to take it back.
- *
- * Every change a designer makes goes through here rather than through spread-updates scattered
- * across components. Two reasons, and the second is the real one:
- *
- *   - Undo/redo is only correct if every edit is a pure replacement of the whole template. Get
- *     that right once and the history is three lines; get it wrong and undo silently loses work.
- *   - These operations are testable without a browser, and a designer's edit rules — what a new
- *     band may hold, what removing a column also removes — are worth asserting.
- *
- * Nothing here mutates. Nothing here validates either: a template is malformed for most of the
- * time it is being edited, and refusing an intermediate state is how an editor becomes unusable.
- * `validateTemplate` is what a Save button asks. An operation that finds nothing to change returns
- * the template it was given, so a caller can skip a re-render.
- */
 import type { AlignedCell, AlignedRow, Band, BandKind, Block, CellLine, ColumnSpec, HeaderGroup, ReportConditionGroup, ReportRegistry, ReportTemplate, SectionSpec, TableBlock, TableData, TemplateOption, TextRow, Watermark } from '../../../published/dcs-ui/src/publicTypes';
 export declare const newBandId: (t: ReportTemplate) => string;
 export declare const newBlockId: (t: ReportTemplate) => string;
-/** An empty band of the requested kind, with one empty text block so it is visible in a preview. */
 export declare const makeBand: (template: ReportTemplate, kind: BandKind) => Band;
 export declare const addBand: (t: ReportTemplate, kind: BandKind, atIndex?: number) => ReportTemplate;
 export declare const removeBand: (t: ReportTemplate, bandId: string) => ReportTemplate;
 export declare const moveBand: (t: ReportTemplate, bandId: string, toIndex: number) => ReportTemplate;
 export declare const updateBand: (t: ReportTemplate, bandId: string, patch: Partial<Omit<Band, "id">>) => ReportTemplate;
-/** A copy, with fresh band and block ids so the two can be edited apart. */
 export declare const duplicateBand: (t: ReportTemplate, bandId: string) => ReportTemplate;
 export declare const addBlock: (t: ReportTemplate, bandId: string, block: Omit<Block, "id">, atIndex?: number) => ReportTemplate;
 export declare const removeBlock: (t: ReportTemplate, bandId: string, blockId: string) => ReportTemplate;
 export declare const moveBlock: (t: ReportTemplate, bandId: string, blockId: string, toIndex: number) => ReportTemplate;
-/** Moves a block into another band — "put the tax table in the footer". */
 export declare const moveBlockToBand: (t: ReportTemplate, fromBandId: string, blockId: string, toBandId: string, atIndex?: number) => ReportTemplate;
 export declare const updateBlock: (t: ReportTemplate, bandId: string, blockId: string, patch: Record<string, unknown>) => ReportTemplate;
 export declare const addTextRow: (t: ReportTemplate, bandId: string, blockId: string, atIndex?: number) => ReportTemplate;
 export declare const removeTextRow: (t: ReportTemplate, bandId: string, blockId: string, rowId: string) => ReportTemplate;
 export declare const moveTextRow: (t: ReportTemplate, bandId: string, blockId: string, rowId: string, toIndex: number) => ReportTemplate;
 export declare const updateTextRow: (t: ReportTemplate, bandId: string, blockId: string, rowId: string, patch: Partial<Omit<TextRow, "id" | "cells">>) => ReportTemplate;
-/**
- * Adds a cell and re-divides the row evenly.
- *
- * Widths are percentages of the row, so adding a cell without redistributing leaves the row
- * adding up to more than 100 and the last cell running off the page. Splitting evenly is the only
- * behaviour that is always safe; an author can then set the widths they want.
- */
 export declare const addTextCell: (t: ReportTemplate, bandId: string, blockId: string, rowId: string) => ReportTemplate;
 export declare const removeTextCell: (t: ReportTemplate, bandId: string, blockId: string, rowId: string, cellId: string) => ReportTemplate;
 export declare const updateTextCell: (t: ReportTemplate, bandId: string, blockId: string, rowId: string, cellId: string, patch: Record<string, unknown>) => ReportTemplate;
-/** One styled line inside a cell. */
 export declare const addLine: (t: ReportTemplate, bandId: string, blockId: string, rowId: string, cellId: string, content?: string) => ReportTemplate;
 export declare const removeLine: (t: ReportTemplate, bandId: string, blockId: string, rowId: string, cellId: string, segmentId: string) => ReportTemplate;
 export declare const moveLine: (t: ReportTemplate, bandId: string, blockId: string, rowId: string, cellId: string, segmentId: string, toIndex: number) => ReportTemplate;
 export declare const updateLine: (t: ReportTemplate, bandId: string, blockId: string, rowId: string, cellId: string, segmentId: string, patch: Record<string, unknown>) => ReportTemplate;
-/**
- * A new table over a row set: its first few fields as columns, the first taking the spare width,
- * numbers right-aligned, a heading shown, in a box. Something a user sees immediately and edits
- * from, rather than an empty table that prints nothing.
- */
 export declare const makeTableBlock: (registry: ReportRegistry, rowSetKey: string, columnCount?: number) => Omit<TableBlock, "id">;
 export declare const updateTable: (t: ReportTemplate, bandId: string, blockId: string, patch: Partial<Omit<TableBlock, "id" | "type">>) => ReportTemplate;
-/**
- * Merges into the table's data; a key set to `undefined` is removed (`{ group: undefined }` stops
- * grouping). A group whose lookup names only a row set is completed from that row set's `lookup`
- * declaration, so a designer can offer "Sizes" and never ask which field is the id.
- */
 export declare const setTableData: (t: ReportTemplate, bandId: string, blockId: string, patch: Partial<TableData>, registry?: ReportRegistry) => ReportTemplate;
 export declare const addColumn: (t: ReportTemplate, bandId: string, blockId: string, column?: Partial<ColumnSpec>, atIndex?: number) => ReportTemplate;
-/**
- * Removing a column also removes the heading groups and closing-row cells that name it. Left
- * behind, they point at nothing and the table fails validation for a reason the author never saw.
- */
 export declare const removeColumn: (t: ReportTemplate, bandId: string, blockId: string, columnId: string) => ReportTemplate;
 export declare const moveColumn: (t: ReportTemplate, bandId: string, blockId: string, columnId: string, toIndex: number) => ReportTemplate;
 export declare const updateColumn: (t: ReportTemplate, bandId: string, blockId: string, columnId: string, patch: Partial<Omit<ColumnSpec, "id">>) => ReportTemplate;
 export declare const duplicateColumn: (t: ReportTemplate, bandId: string, blockId: string, columnId: string) => ReportTemplate;
-/** Adds a line; a column holding a single value is turned into lines first, keeping that value as line 1. */
 export declare const addCellLine: (t: ReportTemplate, bandId: string, blockId: string, columnId: string, line?: Partial<Omit<CellLine, "id">>, atIndex?: number) => ReportTemplate;
 export declare const updateCellLine: (t: ReportTemplate, bandId: string, blockId: string, columnId: string, lineId: string, patch: Partial<Omit<CellLine, "id">>) => ReportTemplate;
 export declare const removeCellLine: (t: ReportTemplate, bandId: string, blockId: string, columnId: string, lineId: string) => ReportTemplate;
@@ -80,9 +38,7 @@ export declare const moveCellLine: (t: ReportTemplate, bandId: string, blockId:
 export declare const addHeaderGroup: (t: ReportTemplate, bandId: string, blockId: string, group: Omit<HeaderGroup, "id">) => ReportTemplate;
 export declare const updateHeaderGroup: (t: ReportTemplate, bandId: string, blockId: string, groupId: string, patch: Partial<Omit<HeaderGroup, "id">>) => ReportTemplate;
 export declare const removeHeaderGroup: (t: ReportTemplate, bandId: string, blockId: string, groupId: string) => ReportTemplate;
-/** Merges into `sections`, creating them; `null` removes sections along with their rows. */
 export declare const setSections: (t: ReportTemplate, bandId: string, blockId: string, patch: Partial<SectionSpec> | null) => ReportTemplate;
-/** Which aligned rows of a table: the closing rows, or a section's heading or subtotal rows. */
 export type AlignedRowsTarget = 'footer' | 'sectionHeader' | 'sectionFooter';
 export declare const addAlignedRow: (t: ReportTemplate, bandId: string, blockId: string, target: AlignedRowsTarget, atIndex?: number) => ReportTemplate;
 export declare const updateAlignedRow: (t: ReportTemplate, bandId: string, blockId: string, target: AlignedRowsTarget, rowId: string, patch: Partial<Omit<AlignedRow, "id" | "cells">>) => ReportTemplate;
@@ -95,7 +51,6 @@ export declare const addAlignedCell: (t: ReportTemplate, bandId: string, blockId
 }) => ReportTemplate;
 export declare const updateAlignedCell: (t: ReportTemplate, bandId: string, blockId: string, target: AlignedRowsTarget, rowId: string, cellId: string, patch: Partial<Omit<AlignedCell, "id">>) => ReportTemplate;
 export declare const removeAlignedCell: (t: ReportTemplate, bandId: string, blockId: string, target: AlignedRowsTarget, rowId: string, cellId: string) => ReportTemplate;
-/** Everything that can carry a condition, addressed the way a designer's inspector reaches it. */
 export type ConditionTarget = {
     kind: 'band';
     bandId: string;
@@ -149,15 +104,11 @@ export type ConditionTarget = {
 } | {
     kind: 'watermark';
 };
-/** Sets, or with `null` removes, the condition on one thing. */
 export declare const setCondition: (t: ReportTemplate, target: ConditionTarget, group: ReportConditionGroup | null) => ReportTemplate;
-/** The condition currently on one thing, for an inspector to show. */
 export declare const getCondition: (t: ReportTemplate, target: ConditionTarget) => ReportConditionGroup | undefined;
 export declare const setPage: (t: ReportTemplate, patch: Partial<Omit<ReportTemplate["page"], "watermark">>) => ReportTemplate;
-/** Merges into the watermark, creating it; `null` removes it. */
 export declare const setWatermark: (t: ReportTemplate, patch: Partial<Watermark> | null) => ReportTemplate;
 export declare const addOption: (t: ReportTemplate, option?: Partial<TemplateOption>, atIndex?: number) => ReportTemplate;
-/** Renaming the key is allowed; placeholders and conditions reading the old key are the author's to update. */
 export declare const updateOption: (t: ReportTemplate, key: string, patch: Partial<TemplateOption>) => ReportTemplate;
 export declare const removeOption: (t: ReportTemplate, key: string) => ReportTemplate;
 export declare const moveOption: (t: ReportTemplate, key: string, toIndex: number) => ReportTemplate;
@@ -165,22 +116,9 @@ export interface TemplateHistory {
     past: ReportTemplate[];
     present: ReportTemplate;
     future: ReportTemplate[];
-    /**
-     * What produced `present`, when it was coalescing. Consecutive edits sharing a key replace
-     * each other instead of stacking, so typing a header is one undo, not one per keystroke.
-     */
     lastKey?: string;
 }
 export declare const createHistory: (template: ReportTemplate) => TemplateHistory;
-/**
- * Applies an edit and records it.
- *
- * Named `applyTemplateEdit` because `bulk/bulkChangeDetection` already owns `applyEdit` for
- * editing a spreadsheet cell — a different thing entirely.
- *
- * `coalesceKey` groups a run of related edits into one undo step — pass something stable for the
- * thing being edited, e.g. `header:col2`. Omit it for a discrete action like adding a band.
- */
 export declare const applyTemplateEdit: (history: TemplateHistory, edit: (template: ReportTemplate) => ReportTemplate, coalesceKey?: string) => TemplateHistory;
 export declare const canUndo: (h: TemplateHistory) => boolean;
 export declare const canRedo: (h: TemplateHistory) => boolean;

package/dist/types/shared-logic/src/report/fields.d.ts

@@ -1,80 +1,29 @@
-/**
- * Quoin — what a template author is allowed to insert.
- *
- * The designer's field picker, as data. A user must never type `%party.mobil%` and discover the
- * mistake on a printed invoice, so they should not be typing paths at all: they pick from this
- * list, and validation exists for the cases where a template outlives the registry that made it.
- *
- * It is also the honest answer to "why no formula language" — the whole vocabulary is here, it
- * fits on a screen, and everything in it was declared in code by someone who meant it.
- */
 import type { FieldType, ReportRegistry, TableBlock, TemplateOption } from '../../../published/dcs-ui/src/publicTypes';
 export type FieldScope = 'source' | 'row' | 'group' | 'page' | 'computed' | 'option' | 'aggregate';
 export interface FieldOption {
-    /** Exactly what to put into the template: `%party.name%`. */
     insert: string;
-    /** The path inside it: `party.name`. */
     path: string;
     label: string;
-    /** Heading to file it under in a picker. */
     group: string;
     type: FieldType;
     scope: FieldScope;
-    /** Shown as a hint where the plain label would be ambiguous. */
     description?: string;
 }
-/** What an aggregate may cover: the rows in scope, one group value's rows, or a whole row set. */
 export type AggregateOver = 'row' | 'group' | 'rowSets';
 export interface FieldCatalogueOptions {
-    /** The table's row set: `%row.*%` and `%group.*%` fields, and the formats behind them. */
     rowSet?: string;
-    /** Offer `%row.*%`. */
     rowsInScope?: boolean;
-    /** Offer `%group.*%`. Only inside a table that groups. */
     groupsInScope?: boolean;
-    /** The lookup row set naming group values, for `%group.lookup.*%`. */
     lookupRowSet?: string;
-    /** Which aggregates to offer. Empty or absent offers none. */
     aggregatesOver?: AggregateOver[];
-    /** Offer `%page.*%`. Only in a page header or footer. */
     pageInScope?: boolean;
-    /** The template's print options, offered as `%option.*%`. */
     templateOptions?: TemplateOption[];
 }
-/**
- * Everything insertable in one context, in the order a picker should show it: the rows first when
- * they are in scope (that is what an author reaches for most), then the group values, then the
- * document's own values, then the machinery.
- */
 export declare const listFields: (registry: ReportRegistry, options?: FieldCatalogueOptions) => FieldOption[];
-/** Grouped for a picker with headings, preserving the order `listFields` chose. */
 export declare const groupFields: (fields: FieldOption[]) => Array<{
     group: string;
     fields: FieldOption[];
 }>;
-/**
- * Filter for a search box. Matches the label, the path and the group, so both "mobile" and
- * "party." find the same thing.
- */
 export declare const searchFields: (fields: FieldOption[], query: string) => FieldOption[];
-/**
- * Where a placeholder is being written.
- *
- * - `text` — a text block in a content band.
- * - `pageBand` — a text block in a page header or footer.
- * - `column` — a table column's value or a plain line in it.
- * - `groupLine` — a column line repeating over group values.
- * - `groupColumn` — the header or value of a column generated per group value.
- * - `closingRow` — a row closing a table: tax, round off, total.
- * - `closingGroupCell` — a closing-row cell under a generated column.
- * - `sectionRow` — a section's heading or subtotal row.
- * - `condition` — a condition rule, inside the table when one is given.
- */
 export type FieldPlace = 'text' | 'pageBand' | 'column' | 'groupLine' | 'groupColumn' | 'closingRow' | 'closingGroupCell' | 'sectionRow' | 'condition';
-/**
- * Which scopes a place may read, so a picker offers only what will resolve there.
- *
- * This is the same truth `validateTemplate` enforces; keeping it in one function means the picker
- * cannot offer something the validator will then reject.
- */
 export declare const scopeFor: (place: FieldPlace, table?: Pick<TableBlock, "data">, templateOptions?: TemplateOption[]) => FieldCatalogueOptions;

package/dist/types/shared-logic/src/report/format.d.ts

@@ -1,27 +1,5 @@
-/**
- * Report engine — rendering one value as text.
- *
- * This is where "date, or date and time?" and "two decimals or three?" stop being reasons to fork
- * a PDF format. They are `PlaceholderFormat`s on the same field.
- */
 import type { DateFormat, NumberFormat, PlaceholderFormat } from '../../../published/dcs-ui/src/publicTypes';
 export declare const formatNumber: (value: number, fmt?: NumberFormat) => string;
-/**
- * Pattern tokens, longest first so `yyyy` is not eaten by `yy`:
- * `yyyy` `yy` `mmm` (Jan) `mm` `dd` `HH` (24h) `hh` (12h) `nn` (minutes) `ss` `AP` (AM/PM).
- * Anything else is a literal.
- */
 export declare const formatDate: (value: unknown, fmt?: DateFormat) => string;
-/**
- * The single place a value becomes text.
- *
- * An empty value yields `defaultValue` if one is set, otherwise the empty string — and NOT the
- * prefix/suffix, because a stray "Mobile : " on an invoice with no mobile number is exactly the
- * kind of thing the old formats each solved with their own `!!x ? … : ''`.
- */
 export declare const applyFormat: (value: unknown, fmt?: PlaceholderFormat) => string;
-/**
- * Upper, lower or title case. Applied to the whole printed text of a line — literals and values
- * alike — before it is measured, so a heading set in capitals wraps where capitals wrap.
- */
 export declare const applyTextCase: (text: string, textCase?: "upper" | "lower" | "title") => string;