@reportwright/engine 0.0.0-stage → 0.11.0

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

@@ -0,0 +1,121 @@
+export function loadBarcodes(): Promise<void>;
+/**
+ * bwip-js options from an item's flat keys, for its symbology only.
+ * @param {Record<string, any>} item
+ */
+export function bwipOptions(item: Record<string, any>): Record<string, any>;
+/**
+ * Why a symbology cannot draw, with the id that was probably meant ("qr" → "qrcode"); null when it is known.
+ * @param {any} sym
+ */
+export function symbologyError(sym: any): string;
+/** Scale and move every coordinate of an SVG path (absolute and relative commands). */
+export function transformPath(d: any, sx: any, sy: any, tx: any, ty: any): string;
+/**
+ * @param {{ type?: string, text: any, x: number, y: number, w: number, h: number, color?: string, showText?: boolean,
+ *   textHeight?: number, captionAbove?: boolean, options?: Record<string, any> }} a
+ * @returns {{ items: any[], error?: string, twoD?: boolean }} paths in item-local coordinates
+ */
+export function paintBarcode({ type, text, x, y, w, h, color, showText, textHeight, captionAbove, options }: {
+    type?: string;
+    text: any;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    color?: string;
+    showText?: boolean;
+    textHeight?: number;
+    captionAbove?: boolean;
+    options?: Record<string, any>;
+}): {
+    items: any[];
+    error?: string;
+    twoD?: boolean;
+};
+export const SYMBOLOGIES: {
+    id: any;
+    name: any;
+    sample: any;
+    max: number;
+    twoD: boolean;
+}[];
+/** Kept for older callers: the ids in the designer's list. */
+export const BARCODE_TYPES: any[];
+/**
+ * Per-symbology options, as flat item keys. Each is checked against a list or a range: nothing a report
+ * author types reaches bwip-js unchecked.
+ */
+export const BARCODE_OPTIONS: ({
+    key: string;
+    label: string;
+    for: string[];
+    opt: string;
+    enum: string[];
+    int?: undefined;
+    str?: undefined;
+    size?: undefined;
+    bool?: undefined;
+    num?: undefined;
+} | {
+    key: string;
+    label: string;
+    for: string[];
+    opt: string;
+    int: number[];
+    str: boolean;
+    enum?: undefined;
+    size?: undefined;
+    bool?: undefined;
+    num?: undefined;
+} | {
+    key: string;
+    label: string;
+    for: string[];
+    opt: string;
+    int: number[];
+    enum?: undefined;
+    str?: undefined;
+    size?: undefined;
+    bool?: undefined;
+    num?: undefined;
+} | {
+    key: string;
+    label: string;
+    for: string[];
+    opt: string;
+    size: boolean;
+    enum?: undefined;
+    int?: undefined;
+    str?: undefined;
+    bool?: undefined;
+    num?: undefined;
+} | {
+    key: string;
+    label: string;
+    for: string[];
+    opt: string;
+    bool: boolean;
+    enum?: undefined;
+    int?: undefined;
+    str?: undefined;
+    size?: undefined;
+    num?: undefined;
+} | {
+    key: string;
+    label: string;
+    for: string[];
+    opt: string;
+    num: number[];
+    enum?: undefined;
+    int?: undefined;
+    str?: undefined;
+    size?: undefined;
+    bool?: undefined;
+})[];
+/**
+ * Every symbology bwip-js draws (its symbolList bcids, kept here so a check needs no 1 MB import; a test compares).
+ * A report may use any of them; the designer offers SYMBOLOGIES.
+ */
+export const BWIP_IDS: Set<string>;
+export function isTwoD(id: string): boolean;

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

@@ -0,0 +1,11 @@
+/**
+ * A table row's cells by column (null where nothing starts). Two forms, both accepted:
+ * - one entry per column, null under a colSpan (ReportWright's own form);
+ * - RDL / HTML style: the row has fewer cells than columns and spans, the spanned cells are omitted.
+ * covered: [k, j] pairs, cell k (0-based, own form) sits under the colSpan of cell j; it is not drawn.
+ * @param {any} cells @param {number} ncols @returns {{ at: any[], covered: [number, number][] }}
+ */
+export function rowCells(cells: any, ncols: number): {
+    at: any[];
+    covered: [number, number][];
+};

package/dist/types/src/engine/items/chart-kit.d.ts

@@ -0,0 +1,75 @@
+/** A palette by name, or a custom list of #hex colours. */
+export function paletteOf(p: any): any;
+/** WCAG contrast ratio of two #hex colours (1 when either is not a colour). */
+export function contrast(a: any, b: any): number;
+/** White or near-black, whichever reads better on the fill. */
+export function inkOn(fill: any): "#111827" | "#ffffff";
+/** "Nice" axis bounds and step (Heckbert). */
+export function niceScale(min: any, max: any, ticks?: number): {
+    lo: number;
+    hi: number;
+    step: number;
+};
+/** Ticks from lo to hi by step, rounded so 0.1 + 0.2 reads 0.3. At most 200 (a bad min/max cannot loop for ever). */
+export function linearTicks(lo: any, hi: any, step: any): any[];
+/** Powers of ten covering [min, max] (both > 0); at least two. */
+export function logTicks(min: any, max: any): number[];
+/**
+ * An SVG path through points (in drawing order along the category axis).
+ * `along: 'y'` when the categories run down the page (a bar chart): the curve is then monotone in y.
+ * @param {{x:number,y:number}[]} pts
+ * @param {'straight'|'smooth'|'step'} mode
+ * @param {{along?: 'x'|'y', move?: boolean}} [o] move: false continues an existing path (L to the first point)
+ */
+export function curvePath(pts: {
+    x: number;
+    y: number;
+}[], mode?: "straight" | "smooth" | "step", { along, move }?: {
+    along?: "x" | "y";
+    move?: boolean;
+}): string;
+/**
+ * Least-squares trend through [x, y] pairs.
+ * @param {[number, number][]} pts
+ * @param {'linear'|'exp'|'poly'} kind
+ * @returns {{at: (x:number) => number, order: number} | null}
+ */
+export function fitTrend(pts: [number, number][], kind?: "linear" | "exp" | "poly", order?: number): {
+    at: (x: number) => number;
+    order: number;
+} | null;
+/** Trailing moving average: null until `period` values are in; a missing value starts the count again. */
+export function movingAverage(values: any, period: any): any[];
+export namespace CAPS {
+    let categories: number;
+    let series: number;
+    let points: number;
+    let overlays: number;
+    let period: number;
+}
+export namespace PALETTES {
+    let _default: string[];
+    export { _default as default };
+    export let office: string[];
+    export let colorblind: string[];
+    export let vivid: string[];
+    export let pastel: string[];
+    export let ocean: string[];
+    export let sunset: string[];
+    export let forest: string[];
+    export let berry: string[];
+    export let earth: string[];
+    export let grayscale: string[];
+    export let highContrast: string[];
+}
+export const DARK_INK: "#111827";
+/** Accepts label boxes that stay inside the plot and overlap no box placed before. Grid buckets keep it near linear. */
+export class LabelPlacer {
+    constructor(bounds: any, cell?: number);
+    b: any;
+    cell: number;
+    grid: Map<any, any>;
+    fits(r: any): boolean;
+    place(r: any): boolean;
+    keys(r: any): Generator<string, void, unknown>;
+}

package/dist/types/src/engine/items/chart-more.d.ts

@@ -0,0 +1,52 @@
+/** Legend entries for these types (the series legend does not fit them). */
+export function moreLegend(type: any, item: any, data: any, pal: any): {
+    name: any;
+    color: any;
+}[];
+export function paintMore(type: any, g: any): any;
+/**
+ * Squarified treemap (Bruls, Huizing, van Wijk): values sorted largest first, laid out in rows along the shorter side,
+ * a row closed when adding the next value would make its worst aspect ratio worse. Linear after the sort.
+ * @returns {{x:number,y:number,w:number,h:number,i:number}[]}
+ */
+export function squarify(items: any, x: any, y: any, w: any, h: any): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    i: number;
+}[];
+/** Bins over [lo, hi]: a count (default: Sturges) or a width. At most MORE_CAPS.bins; linear in the values. */
+export function binValues(vals: any, { binCount, binWidth }?: {}): {
+    lo: number;
+    hi: number;
+    width: number;
+    counts: any[];
+    capped: boolean;
+};
+/** Quartiles (linear interpolation, as Excel QUARTILE.INC), whiskers at the furthest values within 1.5 IQR, outliers beyond. */
+export function boxStats(sorted: any): {
+    min: any;
+    max: any;
+    q1: any;
+    med: any;
+    q3: any;
+    lo: any;
+    hi: any;
+    outliers: any[];
+    mean: number;
+    n: any;
+};
+/** Date ticks: the first step of day, week, month, quarter, year that gives at most `max` ticks. */
+export function dateTicks(lo: any, hi: any, max?: number): {
+    ticks: number[];
+    unit: string | number;
+} | {
+    ticks: any[];
+    unit: string;
+};
+export const MORE_TYPES: Set<string>;
+export namespace MORE_CAPS {
+    let bins: number;
+    let outliers: number;
+}

package/dist/types/src/engine/items/chart-round.d.ts

@@ -0,0 +1,28 @@
+export function arc(cx: any, cy: any, r: any, ri: any, a0: any, a1: any): string;
+export function paintRound(type: any, g: any): void;
+/**
+ * Outside pie labels: one column each side; on a side the labels keep their slice order and are pushed apart (down, then
+ * back up from the bottom) so none overlap. When a side has more labels than fit, the smallest slices lose theirs.
+ * Each label is joined to its slice: from the rim, out to an elbow, then across to the label.
+ */
+export function placeOutside(sides: any, { cx, cy, r, lw, lh, lo, hi, out, text, texts, fs, ink }: {
+    cx: any;
+    cy: any;
+    r: any;
+    lw: any;
+    lh: any;
+    lo: any;
+    hi: any;
+    out: any;
+    text: any;
+    texts: any;
+    fs: any;
+    ink: any;
+}): void;
+export const ROUND_TYPES: Set<string>;
+export namespace GAUGE_SHAPES {
+    let half: number[];
+    let threeQuarter: number[];
+    let full: number[];
+}
+export const GAUGE_INDICATORS: string[];

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

@@ -0,0 +1,42 @@
+/** Categories × series values from the data. */
+export function chartData(item: any, ctx: any, lc: any, pal?: any): {
+    categories: any[];
+    buckets: any[];
+    series: any[];
+    rows: any;
+};
+/**
+ * Paint the chart into item-local coordinates (x from item.x, y from 0).
+ * meta.alt receives the chart's generated alt text (its type, title, series and categories).
+ * @param {{ alt?: string }} [meta]
+ * @returns {any[]} page-model items
+ */
+export function paintChart(item: any, ctx: any, lc: any, base: any, meta?: {
+    alt?: string;
+}): any[];
+/** Overlays the legend lists (each unless legend: false), with the key each draws: a line (dashed for trends) or a band. */
+export function legendOverlays(item: any, type: any, data: any): ({
+    name: string;
+    color: any;
+    mark: string;
+    dash: boolean;
+} | {
+    name: string;
+    color: any;
+    mark: string;
+    dash?: undefined;
+})[];
+/**
+ * The robust window of a set of values: its 1st and 99th percentiles (nearest rank). extreme: the full spread is more
+ * than five times that window, so a few outliers would flatten the rest of the data.
+ * @param {number[]} vals
+ */
+export function robustWindow(vals: number[]): {
+    p1: number;
+    p99: number;
+    extreme: boolean;
+};
+export { niceScale };
+export const PALETTE: string[];
+export const CHART_TYPES: string[];
+import { niceScale } from './chart-kit.js';

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

@@ -0,0 +1,33 @@
+/** The left edge of a page-model item. */
+export function itemLeft(it: any): any;
+/**
+ * @param {{ units: any[], height: number, headerCount: number, headerHeight: number, repeatHeader: boolean,
+ *   colX: number[], widths: number[], x: number, repeat: number, room: number, order: 'down' | 'across', pageH: number,
+ *   name: string, nextId: () => number, warn: (m: string, clip?: boolean) => void, shiftLocal: (items: any[], dy: number) => any[],
+ *   block?: number }} o  block: columns that move together (a pivot's value columns per measure), default 1
+ * @returns {{ height: number, units: any[], tables: any[], width: number } | null}  null when the columns fit
+ */
+export function sliceColumns(o: {
+    units: any[];
+    height: number;
+    headerCount: number;
+    headerHeight: number;
+    repeatHeader: boolean;
+    colX: number[];
+    widths: number[];
+    x: number;
+    repeat: number;
+    room: number;
+    order: "down" | "across";
+    pageH: number;
+    name: string;
+    nextId: () => number;
+    warn: (m: string, clip?: boolean) => void;
+    shiftLocal: (items: any[], dy: number) => any[];
+    block?: number;
+}): {
+    height: number;
+    units: any[];
+    tables: any[];
+    width: number;
+} | null;

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;