@reportwright/engine 0.0.0-stage → 0.12.0

package/dist/types/src/engine/items/index.d.ts

@@ -0,0 +1,117 @@
+export function register(type: any, spec: any): void;
+export function textOf(raw: any, st: any, ctx: any, lc: any): any;
+/**
+ * A number for data export: the full value, as SSRS exports it (Excel's number format does the display rounding, so a
+ * column of 0.333, 0.333, 0.334 shown as N2 still sums to 1). Only binary noise past 15 significant digits goes
+ * (0.30000000000000004 is 0.3), which Excel would not show either. fmt is unused (kept for the call sites).
+ */
+export function roundFor(v: any, fmt: any): any;
+/** A layout context whose expressions read PartProperties.<name> from `props` (a report part's values). */
+export function withPartProps(lc: any, props: any): any;
+/** Style props the inspector shows for an item type. */
+export function stylePropsFor(type: any): any;
+/**
+ * Item registry. Each item type has:
+ *   label, defaults(), props (designer metadata, plain data),
+ *   layout(item, lc) → { height, units[], table? }
+ * Unit coordinates: x in content space, y relative to the item top.
+ */
+/** @type {Record<string, any>} */
+export const ITEMS: Record<string, any>;
+export const GROW_TOLERANCE: 1;
+export namespace SHRINK_DEFAULTS {
+    let minFontSize: number;
+    let step: number;
+}
+export const TEXT_STYLE_PROPS: ({
+    key: string;
+    label: string;
+    type: string;
+    category: string;
+    expr?: undefined;
+    options?: undefined;
+    labelKey?: undefined;
+} | {
+    key: string;
+    label: string;
+    type: string;
+    category: string;
+    expr: boolean;
+    options?: undefined;
+    labelKey?: undefined;
+} | {
+    key: string;
+    label: string;
+    type: string;
+    options: string[];
+    category: string;
+    expr: boolean;
+    labelKey?: undefined;
+} | {
+    key: string;
+    label: string;
+    type: string;
+    options: string[];
+    category: string;
+    expr?: undefined;
+    labelKey?: undefined;
+} | {
+    key: string;
+    label: string;
+    labelKey: string;
+    type: string;
+    category: string;
+    expr?: undefined;
+    options?: undefined;
+})[];
+export namespace SHAPE_STYLE_PROPS {
+    namespace fill {
+        let key: string;
+        let label: string;
+        let type: string;
+        let category: string;
+    }
+    namespace stroke {
+        let key_1: string;
+        export { key_1 as key };
+        let label_1: string;
+        export { label_1 as label };
+        let type_1: string;
+        export { type_1 as type };
+        let category_1: string;
+        export { category_1 as category };
+    }
+    namespace strokeWidth {
+        let key_2: string;
+        export { key_2 as key };
+        let label_2: string;
+        export { label_2 as label };
+        let type_2: string;
+        export { type_2 as type };
+        let category_2: string;
+        export { category_2 as category };
+    }
+    namespace strokeDash {
+        let key_3: string;
+        export { key_3 as key };
+        let label_3: string;
+        export { label_3 as label };
+        let type_3: string;
+        export { type_3 as type };
+        export let options: string[];
+        let category_3: string;
+        export { category_3 as category };
+    }
+    namespace radius {
+        let key_4: string;
+        export { key_4 as key };
+        let label_4: string;
+        export { label_4 as label };
+        let type_4: string;
+        export { type_4 as type };
+        let category_4: string;
+        export { category_4 as category };
+    }
+}
+export { isDynamic };
+import { isDynamic } from '../expr/evaluate.js';

package/dist/types/src/engine/items/map.d.ts

@@ -0,0 +1,11 @@
+/** @returns {number[][][] | null} lines → [lon, lat] */
+export function linesOf(g: any): number[][][] | null;
+/** @returns {number[][][][] | null} polygons → rings → [lon, lat] */
+export function polygonsOf(g: any): number[][][][] | null;
+export function paintMap(item: any, ctx: any, lc: any, base: any): any[];
+export namespace MAP_CAPS {
+    let shapes: number;
+    let coords: number;
+    let points: number;
+    let classes: number;
+}

package/dist/types/src/engine/items/paint.d.ts

@@ -0,0 +1,138 @@
+/** Text layout for a box: lines, font key, needed height. */
+export function layoutTextLines(text: any, st: any, width: any, m: any, opt: any): any;
+/**
+ * Paint a box: background, text lines, borders.
+ * @returns {any[]} page-model items (appended to `out` when given)
+ */
+export function paintBox({ x, y, w, h, st, tl, numeric, m, ellipsis, out, cell }: {
+    x: any;
+    y: any;
+    w: any;
+    h: any;
+    st: any;
+    tl: any;
+    numeric?: boolean;
+    m: any;
+    ellipsis?: boolean;
+    out?: any;
+    cell?: any;
+}): any[];
+/**
+ * paintBox with positional arguments (no argument object: table cells call it hundreds of thousands of times).
+ * cell: the text's table cell tag (export data), set when the text item is made: one added later would not fit the
+ * object and costs a separate property store per item.
+ */
+export function paintBoxAt(x: any, y: any, w: any, h: any, st: any, tl: any, numeric: any, m: any, ellipsis: any, items: any, cell?: any): any;
+export namespace paintBoxAt {
+    let shapes: ({
+        x: any;
+        y: any;
+        w: any;
+        h: any;
+        text?: undefined;
+        t?: undefined;
+        font?: undefined;
+        size?: undefined;
+        color?: undefined;
+        lines?: undefined;
+        clip?: undefined;
+        fill?: undefined;
+        x1?: undefined;
+        y1?: undefined;
+        x2?: undefined;
+        y2?: undefined;
+        stroke?: undefined;
+        strokeWidth?: undefined;
+        dash?: undefined;
+    } | {
+        x: any;
+        y: any;
+        text: any;
+        w: any;
+        h?: undefined;
+        t?: undefined;
+        font?: undefined;
+        size?: undefined;
+        color?: undefined;
+        lines?: undefined;
+        clip?: undefined;
+        fill?: undefined;
+        x1?: undefined;
+        y1?: undefined;
+        x2?: undefined;
+        y2?: undefined;
+        stroke?: undefined;
+        strokeWidth?: undefined;
+        dash?: undefined;
+    } | {
+        t: any;
+        font: any;
+        size: any;
+        color: any;
+        lines: any;
+        clip: any;
+        x?: undefined;
+        y?: undefined;
+        w?: undefined;
+        h?: undefined;
+        text?: undefined;
+        fill?: undefined;
+        x1?: undefined;
+        y1?: undefined;
+        x2?: undefined;
+        y2?: undefined;
+        stroke?: undefined;
+        strokeWidth?: undefined;
+        dash?: undefined;
+    } | {
+        t: any;
+        x: any;
+        y: any;
+        w: any;
+        h: any;
+        fill: any;
+        text?: undefined;
+        font?: undefined;
+        size?: undefined;
+        color?: undefined;
+        lines?: undefined;
+        clip?: undefined;
+        x1?: undefined;
+        y1?: undefined;
+        x2?: undefined;
+        y2?: undefined;
+        stroke?: undefined;
+        strokeWidth?: undefined;
+        dash?: undefined;
+    } | {
+        t: any;
+        x1: any;
+        y1: any;
+        x2: any;
+        y2: any;
+        stroke: any;
+        strokeWidth: any;
+        dash: any;
+        x?: undefined;
+        y?: undefined;
+        w?: undefined;
+        h?: undefined;
+        text?: undefined;
+        font?: undefined;
+        size?: undefined;
+        color?: undefined;
+        lines?: undefined;
+        clip?: undefined;
+        fill?: undefined;
+    })[];
+}
+/** Put items on the page at (dx, dy), appending them to `out`. */
+export function placeItems(items: any, dx: any, dy: any, out: any): void;
+/** Move page-model items by (dx, dy). Returns new objects. A rotated item's centre moves with it. */
+export function shiftItems(items: any, dx: any, dy: any): any;
+/**
+ * Item arrays that layout made fresh for one unit and nothing else references (a table row's paint): page assembly
+ * moves their items into place instead of copying them, which halves the page model's peak memory. An array is
+ * moved at most once; any other array is copied (shiftItems), as before.
+ */
+export const OWNED: WeakSet<object>;

package/dist/types/src/engine/items/pivot.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Rows → buckets by an expression's value, in first-seen order. Text keys that differ only in case share a bucket
+ * (SSRS on a case-insensitive collation); the bucket keeps the first row's key and text (toggle state keys).
+ */
+export function groupRows(rows: any, expr: any, ctx: any, lc: any, who: any, adjacent?: boolean): any[];
+/**
+ * The array form of a matrix. The old single-group keys map onto one row group, one column group and one value.
+ * @returns {{ rowGroups: any[], columnGroups: any[], values: any[], legacy: boolean, overflow: string, pageOrder: string }}
+ */
+export function normalizeMatrix(item: any): {
+    rowGroups: any[];
+    columnGroups: any[];
+    values: any[];
+    legacy: boolean;
+    overflow: string;
+    pageOrder: string;
+};
+/**
+ * @param {any} item the matrix
+ * @param {any[]} rows its rows, already filtered
+ * @param {any} ctx evaluation context of the item
+ * @param {any} lc layout context (warn, state)
+ * @returns {{ R: number, C: number, V: number, spec: ReturnType<typeof normalizeMatrix>, cols: any[], header: any[][], body: any[] }}
+ *   cols: one entry per value column (after the R row-header columns): { kind, level, node, v }
+ *   header: header rows, each a list of cells { c, text, rowSpan, colSpan, role, toggle?, action?, bookmark?, ctx? }
+ *   body: rows { kind, level, node, cells: [{ c, text?, raw?, rowSpan, colSpan, role, toggle?, ctx?, action?, bookmark? }] }
+ */
+export function buildPivot(item: any, rows: any[], ctx: any, lc: any): {
+    R: number;
+    C: number;
+    V: number;
+    spec: ReturnType<typeof normalizeMatrix>;
+    cols: any[];
+    header: any[][];
+    body: any[];
+};
+export namespace PIVOT_LIMITS {
+    let depth: number;
+    let values: number;
+    let columns: number;
+    let cells: number;
+    let tree: number;
+}
+export function cmpKey(a: any, b: any, ctx: any): number;
+export function isTablix(item: any): boolean;

package/dist/types/src/engine/items/rich.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The markup of a rich text value. Only the literal markup the author typed is HTML. Everything that comes
+ * from evaluation (a {Fields.x} part of a template, or the result of a value that is one =expression) is
+ * escaped and shows as text, unless the item sets `htmlFromData: true` (HTML stored in trusted data); then
+ * it is parsed too, through the same allow-list.
+ * @param {any} v @param {any} ctx @param {boolean} [htmlFromData]
+ */
+export function richValue(v: any, ctx: any, htmlFromData?: boolean): string;
+/**
+ * @typedef {{ id: string, key: string, size: number, lineSize: number, rise: number, color: string,
+ *   under: boolean, strike: boolean, bg?: string, href?: string }} Look
+ * @typedef {{ text: string, look: Look, x: number, w: number }} Frag
+ * @typedef {{ frags: Frag[], w: number, h: number, base: number, left: number, align: string, p: number, br: boolean, gap: number }} RichLine
+ */
+/**
+ * @param {import('../text/rich.js').RichBlock[]} blocks
+ * @param {any} st the item's resolved style
+ * @param {number} width
+ * @param {import('../text/measure.js').TextMeasurer} m
+ * @param {{ listIndent?: number, paragraphSpacing?: number, maxLineHeight?: number, warn?: (msg: string) => void }} [opt]
+ */
+export function layoutRich(blocks: import("../text/rich.js").RichBlock[], st: any, width: number, m: import("../text/measure.js").TextMeasurer, opt?: {
+    listIndent?: number;
+    paragraphSpacing?: number;
+    maxLineHeight?: number;
+    warn?: (msg: string) => void;
+}): {
+    lines: RichLine[];
+    needed: any;
+    pad: any;
+    inner: number;
+    fragments: number;
+};
+/**
+ * Page-model items for rich text lines in a box: background, span backgrounds, one text item per fragment,
+ * decorations, borders, then links. Lines that do not fit the box are left out.
+ * @param {{ x: number, y: number, w: number, h: number, st: any, rl: { lines: RichLine[], pad: number[], inner: number },
+ *   m: import('../text/measure.js').TextMeasurer, id: string }} o
+ */
+export function paintRich({ x, y, w, h, st, rl, m, id }: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    st: any;
+    rl: {
+        lines: RichLine[];
+        pad: number[];
+        inner: number;
+    };
+    m: import("../text/measure.js").TextMeasurer;
+    id: string;
+}): any[];
+/**
+ * Vertical text (writing-mode tb-rl): columns from right to left, each read top to bottom. Upright characters
+ * (CJK) are stacked one em apart, one text item per column; runs of other text (Latin, digits) are text items
+ * turned 90° clockwise about their own centre, so every exporter draws them with Phase 1's rotation.
+ * The box keeps its designed size; text past the last column that fits is left out.
+ * @param {{ x: number, y: number, w: number, h: number, st: any, text: string, m: import('../text/measure.js').TextMeasurer }} o
+ */
+export function paintVertical({ x, y, w, h, st, text, m }: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    st: any;
+    text: string;
+    m: import("../text/measure.js").TextMeasurer;
+}): any[];
+export namespace RICH_DEFAULTS {
+    let listIndent: number;
+    let paragraphSpacing: number;
+    let linkColor: string;
+    let maxFragments: number;
+    let maxLines: number;
+}
+export type Look = {
+    id: string;
+    key: string;
+    size: number;
+    lineSize: number;
+    rise: number;
+    color: string;
+    under: boolean;
+    strike: boolean;
+    bg?: string;
+    href?: string;
+};
+export type Frag = {
+    text: string;
+    look: Look;
+    x: number;
+    w: number;
+};
+export type RichLine = {
+    frags: Frag[];
+    w: number;
+    h: number;
+    base: number;
+    left: number;
+    align: string;
+    p: number;
+    br: boolean;
+    gap: number;
+};

package/dist/types/src/engine/items/toc.d.ts

@@ -0,0 +1,10 @@
+/** @param {number} n @param {string} kind 'decimal' | 'roman' | 'alpha' */
+export function formatNumber(n: number, kind: string): string;
+/**
+ * The number of each entry. A deeper level restarts when a higher one moves on; a skipped level counts as 1.
+ * @param {{ level?: number }[]} entries
+ * @param {string | string[]} numbering one format for every level, or one per level (the last repeats)
+ */
+export function tocNumbers(entries: {
+    level?: number;
+}[], numbering: string | string[]): string[];

package/dist/types/src/engine/items/visuals.d.ts

@@ -0,0 +1,5 @@
+/** @param {{ cell?: boolean }} [opt] cell: drawn in a table cell, sized and aligned to its text line */
+export function paintVisual(v: any, box: any, ctx: any, lc: any, base: any, who?: string, opt?: {
+    cell?: boolean;
+}): any[];
+export const ICON_SETS: string[];

package/dist/types/src/engine/layout.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Lay out a set of free-positioned items (a band body, a container, one list row).
+ * Applies the RDL push rule: when an item grows by Δ, every item below it that
+ * overlaps it horizontally moves down by Δ.
+ *
+ * @param {any[]} items
+ * @param {any} lc  layout context
+ * @param {{ dx?: number }} [opt]  x offset of the parent
+ * @returns {{ units: any[], tables: any[], height: number }}
+ *   units and tables in coordinates relative to the top of this set
+ */
+export function layoutItems(items: any[], lc: any, { dx }?: {
+    dx?: number;
+}): {
+    units: any[];
+    tables: any[];
+    height: number;
+};
+/**
+ * Which items a render leaves out because of their layer: `layers: [{ name, target, visible }]`. Targets follow
+ * ActiveReports' TargetDevice: all, screen, print (paper), export, design (none: the designer only).
+ * @returns {((it: any) => boolean) | null}
+ */
+export function layerFilter(layers: any, target: any): ((it: any) => boolean) | null;

package/dist/types/src/engine/paged.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @param {any} def0 @param {any} opts render() options, and maxRows/sorter/sqlRows as planStream takes them;
+ *   window: rows per window (tests)
+ * @returns {Promise<{ why: string } | { why?: undefined, pages: () => AsyncGenerator<any>, info: { width: number, height: number, bookmarks: any[], headings: any[], warnings: string[], pages: number } }>}
+ */
+export function planPaged(def0: any, opts?: any): Promise<{
+    why: string;
+} | {
+    why?: undefined;
+    pages: () => AsyncGenerator<any>;
+    info: {
+        width: number;
+        height: number;
+        bookmarks: any[];
+        headings: any[];
+        warnings: string[];
+        pages: number;
+    };
+}>;

package/dist/types/src/engine/paginate/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {any[]} units  sorted by top
+ * @param {any[]} tables
+ * @param {number} pageH  content height available for the body
+ * @param {(msg: string, clip?: boolean) => void} warn
+ * @param {{ work: number }} [stats]  counts the comparisons the search makes (the complexity test reads it)
+ * @returns {{ top: number, bottom: number, offset: number, repeat: any[], units: any[] }[]}
+ */
+export function paginate(units: any[], tables: any[], pageH: number, warn: (msg: string, clip?: boolean) => void, stats?: {
+    work: number;
+}): {
+    top: number;
+    bottom: number;
+    offset: number;
+    repeat: any[];
+    units: any[];
+}[];

package/dist/types/src/engine/reuse.d.ts

@@ -0,0 +1,120 @@
+/**
+ * A loader for one render (and its subreports): each id loaded once, at most REUSE_LIMITS.reports ids.
+ * @param {((id: string) => Promise<any>) | undefined} load
+ * @param {Map<string, Promise<any>>} [cache]
+ */
+export function makeLoader(load: ((id: string) => Promise<any>) | undefined, cache?: Map<string, Promise<any>>): (id: any) => Promise<any>;
+/** Report ids a definition reuses by a fixed id (not expressions): master, stylesheet, theme and part libraries. */
+export function reuseRefs(def: any): Set<any>;
+/**
+ * The reports a definition opens by a fixed id: drill-through actions (an item's, a cell's, a chart point's, a matrix
+ * header's) and subreports, each with where it is ("Ledger cell", "Chart1"). Ids given by an expression are not listed.
+ * @param {any} def @returns {{ report: string, where: string }[]}
+ */
+export function drillRefs(def: any): {
+    report: string;
+    where: string;
+}[];
+export function findItemNamed(def: any, name: any): any;
+/**
+ * The content report merged with its master (and the master's master, up to REUSE_LIMITS.depth).
+ * @param {any} def @param {(id: string) => Promise<any>} get @param {(m: string) => void} warn @param {string[]} [chain]
+ */
+export function applyMaster(def: any, get: (id: string) => Promise<any>, warn: (m: string) => void, chain?: string[]): any;
+/** Named styles with `parent` resolved: each style is its parents' properties with its own on top. */
+export function flattenNamed(named: any, warn?: (_m: any) => void): Record<string, any>;
+/**
+ * Masters, stylesheet and part libraries, before validation. Themes come later (they may depend on parameters).
+ * @returns {Promise<{ def: any, parts: Map<string, any> | null }>}
+ */
+export function resolveReuse(def: any, get: any, warn: any, chain?: any[], budget?: {
+    items: number;
+}): Promise<{
+    def: any;
+    parts: Map<string, any> | null;
+}>;
+/** A theme definition as expressions read it: Theme.Colors.Accent1, Theme.Fonts.MajorFont.Family, Theme.Constants.Name. */
+export function themeContext(td: any): {
+    Colors: any;
+    Fonts: {
+        MajorFont: {
+            Family: any;
+            Size: any;
+            Weight: any;
+            Style: any;
+        };
+        MinorFont: {
+            Family: any;
+            Size: any;
+            Weight: any;
+            Style: any;
+        };
+    };
+    Constants: any;
+};
+/** The render's theme: `theme` (a report id, or an expression giving one), else the report's own `themeDef`, else the default. */
+export function resolveTheme(def: any, ctx: any, get: any, warn: any): Promise<{
+    Colors: any;
+    Fonts: {
+        MajorFont: {
+            Family: any;
+            Size: any;
+            Weight: any;
+            Style: any;
+        };
+        MinorFont: {
+            Family: any;
+            Size: any;
+            Weight: any;
+            Style: any;
+        };
+    };
+    Constants: any;
+}>;
+export namespace REUSE_LIMITS {
+    let depth: number;
+    let reports: number;
+    let items: number;
+    let reportItems: number;
+    let parts: number;
+    let layers: number;
+    let styleDepth: number;
+    let repeats: number;
+}
+export function isReportId(v: any): boolean;
+export function isSubreportId(v: any): boolean;
+export namespace DEFAULT_THEME {
+    namespace colors {
+        let Dark1: string;
+        let Light1: string;
+        let Dark2: string;
+        let Light2: string;
+        let Accent1: string;
+        let Accent2: string;
+        let Accent3: string;
+        let Accent4: string;
+        let Accent5: string;
+        let Accent6: string;
+        let Hyperlink: string;
+    }
+    namespace fonts {
+        namespace major {
+            let family: string;
+            let size: number;
+            let weight: string;
+            let style: string;
+        }
+        namespace minor {
+            let family_1: string;
+            export { family_1 as family };
+            let size_1: number;
+            export { size_1 as size };
+            let weight_1: string;
+            export { weight_1 as weight };
+            let style_1: string;
+            export { style_1 as style };
+        }
+    }
+    let constants: {};
+}
+export const THEME_COLORS: string[];