@reportwright/engine 0.0.0-stage → 0.11.0

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/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[];