@dcs-tech/ui 0.2.0 → 0.4.0

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

@@ -1,106 +0,0 @@
-/**
- * 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';
-} | {
-    kind: 'options';
-} | {
-    kind: 'band';
-    bandId: string;
-} | {
-    kind: 'block';
-    bandId: string;
-    blockId: string;
-} | {
-    kind: 'column';
-    bandId: string;
-    blockId: string;
-    columnId: string;
-} | {
-    kind: 'textRow';
-    bandId: string;
-    blockId: string;
-    rowId: string;
-} | {
-    kind: 'textCell';
-    bandId: string;
-    blockId: string;
-    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 +0,0 @@
-/**
- * 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 +0,0 @@
-/**
- * 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,49 +0,0 @@
-/**
- * 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;
-    order: number;
-    lookup?: Row;
-}
-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,188 +0,0 @@
-/**
- * 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;
-export declare const moveCellLine: (t: ReportTemplate, bandId: string, blockId: string, columnId: string, lineId: string, toIndex: number) => ReportTemplate;
-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;
-export declare const removeAlignedRow: (t: ReportTemplate, bandId: string, blockId: string, target: AlignedRowsTarget, rowId: string) => ReportTemplate;
-export declare const moveAlignedRow: (t: ReportTemplate, bandId: string, blockId: string, target: AlignedRowsTarget, rowId: string, toIndex: number) => ReportTemplate;
-export declare const addAlignedCell: (t: ReportTemplate, bandId: string, blockId: string, target: AlignedRowsTarget, rowId: string, cell: {
-    from: string;
-    to?: string;
-    content?: string;
-}) => 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;
-} | {
-    kind: 'block';
-    bandId: string;
-    blockId: string;
-} | {
-    kind: 'textRow';
-    bandId: string;
-    blockId: string;
-    rowId: string;
-} | {
-    kind: 'textCell';
-    bandId: string;
-    blockId: string;
-    rowId: string;
-    cellId: string;
-} | {
-    kind: 'segment';
-    bandId: string;
-    blockId: string;
-    rowId: string;
-    cellId: string;
-    segmentId: string;
-} | {
-    kind: 'column';
-    bandId: string;
-    blockId: string;
-    columnId: string;
-} | {
-    kind: 'cellLine';
-    bandId: string;
-    blockId: string;
-    columnId: string;
-    lineId: string;
-} | {
-    kind: 'alignedRow';
-    bandId: string;
-    blockId: string;
-    rows: AlignedRowsTarget;
-    rowId: string;
-} | {
-    kind: 'alignedSegment';
-    bandId: string;
-    blockId: string;
-    rows: AlignedRowsTarget;
-    rowId: string;
-    cellId: string;
-    segmentId: string;
-} | {
-    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;
-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;
-export declare const undo: (h: TemplateHistory) => TemplateHistory;
-export declare const redo: (h: TemplateHistory) => TemplateHistory;

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

@@ -1,80 +0,0 @@
-/**
- * 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 +0,0 @@
-/**
- * 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;

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

@@ -1,61 +0,0 @@
-/**
- * Quoin — a template built from a column list.
- *
- * Most reports are a title, a table, optional sections and a totals row. Hand-writing a template
- * for each of those would be as much work as the hand-written generators this replaces, so this
- * derives one. Give it the columns a screen table already has and it returns a template plus the
- * registry describing them — no template file, no field declarations.
- *
- * Deliberately generic: it knows nothing about the Table component, or invoices. An app maps its
- * own column type onto `GridColumn` and gets a report.
- *
- * Totals and subtotals are rows laid on the table's own columns, so each figure sits under its
- * column whatever width the columns declare.
- */
-import type { PageConfig, ReportRegistry, ReportTemplate } from '../../../published/dcs-ui/src/publicTypes';
-export type GridColumnType = 'text' | 'number' | 'date' | 'boolean';
-export interface GridColumn {
-    key: string;
-    header: string;
-    type?: GridColumnType;
-    align?: 'left' | 'center' | 'right';
-    /** Decimals for a number column. Defaults to 2 for money-ish values, 0 for counts. */
-    decimals?: number;
-    /** Digit grouping for numbers. */
-    grouping?: 'in' | 'en';
-    /** Date pattern; only meaningful for a date column. */
-    dateFormat?: string;
-    /** Totalled in the closing row, and in each section's subtotal row when grouping. */
-    summable?: boolean;
-    /** Defaults to an equal share of the width. */
-    width?: number | '*' | 'auto';
-}
-export interface GridReportOptions {
-    /** Printed once at the top. */
-    title?: string;
-    /** Second line under the title — a date range, a filter description. */
-    subtitle?: string;
-    /** Repeat the title block on every page rather than page one only. */
-    repeatTitle?: boolean;
-    page?: Partial<PageConfig>;
-    /** Column key to split the rows into sections by. A heading row opens each section; subtotals close it. */
-    groupBy?: string;
-    /** Print `Page n of m` at the foot of every page. Default true. */
-    pageNumbers?: boolean;
-    /** Print a totals row at the end. Default true when any column is summable. */
-    totals?: boolean;
-    /** Label of the totals row. */
-    totalsLabel?: string;
-    id?: string;
-    name?: string;
-}
-/**
- * The registry for a derived report: one row set called `rows`, plus the handful of scalars a
- * heading needs. An app that wants more can extend the result before rendering.
- */
-export declare const registryFromColumns: (columns: GridColumn[], key?: string) => ReportRegistry;
-export interface GridReportResult {
-    template: ReportTemplate;
-    registry: ReportRegistry;
-}
-export declare const templateFromColumns: (columns: GridColumn[], options?: GridReportOptions) => GridReportResult;

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

@@ -1,19 +0,0 @@
-export { REPORT_SCHEMA_VERSION, REPORT_AGGREGATES, CONTINUATION_SUFFIX, BAND_PART_SEPARATOR, TABLE_HEADER_SUFFIX, TABLE_FOOTER_SUFFIX, TABLE_FILL_INFIX, } from './constants';
-export { applyFormat, formatNumber, formatDate, applyTextCase } from './format';
-export { readPath, aggregateRows, type ResolveScope, type GroupScope, type ScopeRow } from './scope';
-export { evaluateReportRule, evaluateReportCondition } from './conditions';
-export { parseAggregate, computeAggregate, type AggregateCall } from './aggregate';
-export { resolveText, buildFormatLookup, PLACEHOLDER, type FormatLookup, type ResolveOptions } from './resolve';
-export { buildTableRows, buildSections, type Row, type TableRow, type GroupKey, type BuiltTableRows, type TableSection, } from './dataset';
-export { lineHeight, textWidth, textHeight, wrapToWidth, minTextWidth, containsNonAscii, mmToPt, PT_PER_MM, PAPER_SIZES_PT, } from './metrics';
-export { layoutDocument, pageContentSize, resolveColumnWidths, expandColumns, resolveOptions, CELL_PAD_X, CELL_PAD_Y, AUTO_COLUMN_SLACK_PT, type LayoutResult, type LayoutOptions, type PlacedColumn, } from './layout';
-export { paginate, type PaginateOptions } from './paginate';
-export { renderToPdfMake, PDFMAKE_CAPABILITIES, type PdfMakeRenderOptions } from './renderers/pdfmake';
-export { validateTemplate, isTemplateValid, formatIssues, type ValidationIssue, type IssueSeverity, } from './validate';
-export { migrateTemplate, migrateTemplatePart, MIGRATIONS, ASSUMED_SCHEMA_VERSION, type MigrationStep, type MigrationResult, } from './migrate';
-export { REPORT_TEMPLATES_SETTINGS_DOC, DIFFABLE_TEMPLATE_KEYS, diffTemplate, buildTemplateEntry, resolveStoredTemplate, loadReportTemplates, activeReportTemplates, type DiffableTemplateKey, type TemplateDiff, type EntryOptions, type TemplateLoadProblem, type LoadedTemplate, } from './storage';
-export { templateFromColumns, registryFromColumns, type GridColumn, type GridColumnType, type GridReportOptions, type GridReportResult, } from './fromColumns';
-export { renderToHtml, type HtmlRenderOptions } from './renderers/html';
-export { listFields, groupFields, searchFields, scopeFor, type FieldOption, type FieldScope, type FieldCatalogueOptions, type AggregateOver, type FieldPlace, } from './fields';
-export { makeBand, addBand, removeBand, moveBand, updateBand, duplicateBand, addBlock, removeBlock, moveBlock, moveBlockToBand, updateBlock, addTextRow, removeTextRow, moveTextRow, updateTextRow, addTextCell, removeTextCell, updateTextCell, addLine, removeLine, moveLine, updateLine, makeTableBlock, updateTable, setTableData, addColumn, removeColumn, moveColumn, updateColumn, duplicateColumn, addCellLine, updateCellLine, removeCellLine, moveCellLine, addHeaderGroup, updateHeaderGroup, removeHeaderGroup, setSections, addAlignedRow, updateAlignedRow, removeAlignedRow, moveAlignedRow, addAlignedCell, updateAlignedCell, removeAlignedCell, setCondition, getCondition, setPage, setWatermark, addOption, updateOption, removeOption, moveOption, newBandId, newBlockId, createHistory, applyTemplateEdit, undo, redo, canUndo, canRedo, type TemplateHistory, type AlignedRowsTarget, type ConditionTarget, } from './edit';
-export { selectionFromCanvas, canvasHighlight, liveSelection, parseBandId, selectionAncestors, type DesignerSelection, type CanvasTarget, type CanvasHighlight, } from './canvas';