@reportwright/engine 0.0.0-stage → 0.11.0

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

@@ -0,0 +1,23 @@
+/**
+ * The one allow-list for links the engine emits (url actions, rich text <a href>), checked on the exact
+ * string that is emitted. Browsers and PDF readers parse URLs leniently (they drop tabs and newlines before
+ * the scheme, read "\" as "/", take "https:x" and "//host" as absolute), so the rule is strict:
+ * - no character at or below U+0020, no DEL or C1 control, no backslash;
+ * - http:// or https:// with a host (double slash required), or mailto:;
+ * - a relative path that starts with one "/" (not "//").
+ * @param {unknown} v
+ * @returns {string|null} v itself when allowed, else null
+ */
+export function safeUrl(v: unknown): string | null;
+/**
+ * A drill-through's address in the ReportWright viewer: `<base>/viewer/<report>?<parameters>` (a list parameter
+ * repeats its name), checked by safeUrl; null without a base URL or a report. The HTML and PDF exports link to it.
+ * @param {string|undefined|null} base @param {{ report?: string, params?: Record<string, any> }} a @returns {string|null}
+ */
+export function drillUrl(base: string | undefined | null, a: {
+    report?: string;
+    params?: Record<string, any>;
+}): string | null;
+/** A URL as a PDF URI action may hold it: 7-bit ASCII (an international host as punycode, other characters
+ *  percent-encoded). @param {string} href @returns {string} */
+export function asciiUrl(href: string): string;

package/dist/types/src/exporters/color.d.ts

@@ -0,0 +1,9 @@
+/** @returns {{r:number,g:number,b:number,a:number}|null} channels 0..1 */
+export function parseColor(c: any): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+} | null;
+/** Safe color for SVG/HTML attributes. */
+export function cssColor(c: any): string;

package/dist/types/src/exporters/csv.d.ts

@@ -0,0 +1,44 @@
+/**
+ * CSV of the report's data: one header row and the detail rows of the main table (the one with the most detail rows),
+ * numbers without symbols or separators, dates in ISO form. Group headers, subtotals, totals and other tables are left
+ * out. layout: true gives the printed layout instead: every table with its name and every row (group lines, totals).
+ * @param {any} model @param {{ all?: boolean, layout?: boolean, locale?: string, currency?: string }} [o]
+ */
+export function exportCsv(model: any, { all, layout, locale, currency }?: {
+    all?: boolean;
+    layout?: boolean;
+    locale?: string;
+    currency?: string;
+}): string;
+/**
+ * A CSV line from a region row (one value per column, empty where no cell starts). Shared by exportCsv and the streaming
+ * writer (writeCsvStream), so both write the same bytes.
+ * @param {{ timeZone?: string|null, locale?: string, currency?: string }} o
+ */
+export function csvLine({ timeZone, locale, currency }: {
+    timeZone?: string | null;
+    locale?: string;
+    currency?: string;
+}): (ncols: any, row: any) => string;
+/** The data CSV's header line: header rows stacked into one, a cell spanning columns naming each of them ("Who Id"). */
+export function csvNames(ncols: any): {
+    /** @param {{ cells: any[] }} row */
+    add(row: {
+        cells: any[];
+    }): void;
+    line: () => string;
+};
+/**
+ * The data CSV of a streaming plan (engine/stream.js), written as its rows come: the same bytes exportCsv writes for the
+ * model of that report. put(text) may return a promise (back-pressure): it is awaited.
+ * @param {{ columns: number[], timeZone: string|null, rows: () => AsyncGenerator<any> }} plan
+ * @param {(s: string) => any} put @param {{ locale?: string, currency?: string }} [o]
+ */
+export function writeCsvStream(plan: {
+    columns: number[];
+    timeZone: string | null;
+    rows: () => AsyncGenerator<any>;
+}, put: (s: string) => any, { locale, currency }?: {
+    locale?: string;
+    currency?: string;
+}): Promise<void>;

package/dist/types/src/exporters/deadline.d.ts

@@ -0,0 +1,6 @@
+/**
+ * An export bounded by opt.timeoutMs: past it the promise rejects with status 504. The work itself is not stopped
+ * (a server render runs in a worker that the pool terminates); the caller is not left waiting.
+ * @template T @param {Promise<T>} work @param {number|undefined} ms @returns {Promise<T>}
+ */
+export function withDeadline<T>(work: Promise<T>, ms: number | undefined): Promise<T>;

package/dist/types/src/exporters/docx.d.ts

@@ -0,0 +1,19 @@
+/** Left, right or centre, from where the lines sit in their box. */
+export function alignOf(it: any): "center" | "left" | "right" | "both";
+/**
+ * @param {any} model render() output
+ * @param {{ title?: string, author?: string, lang?: string, fontStore?: any, fetchImage?: (src: string) => Promise<Uint8Array|null>,
+ *   rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array|null>, figures?: boolean }} [opt]
+ *   fontStore: text in pictures as outlines (else the reader's fallback font); fetchImage: pictures by URL;
+ *   rasterize: the PNG fallback of a picture (default: a canvas in a browser, sharp in Node); figures: false leaves them out.
+ * @returns {Promise<Uint8Array>}
+ */
+export function exportDocx(model: any, opt?: {
+    title?: string;
+    author?: string;
+    lang?: string;
+    fontStore?: any;
+    fetchImage?: (src: string) => Promise<Uint8Array | null>;
+    rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array | null>;
+    figures?: boolean;
+}): Promise<Uint8Array>;

package/dist/types/src/exporters/encrypt.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Algorithm 2.B: the hash of a password, a salt and (for the owner) the U string.
+ * @param {Uint8Array} pw @param {Uint8Array} salt @param {Uint8Array} udata
+ */
+export function hash2B(pw: Uint8Array, salt: Uint8Array, udata: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+/** A password as the handler wants it: NFKC (SASLprep's main step), UTF-8, at most 127 bytes. */
+export function passwordBytes(pw: any, which: any): Uint8Array<ArrayBuffer>;
+/** /P: reserved bits 7, 8 and 13–32 set, 1–2 clear; each permission allowed unless set to false. */
+export function permissionsValue(perms?: {}): number;
+/**
+ * Encrypt a pdf-lib document in place.
+ * @param {import('pdf-lib').PDFDocument} doc
+ * @param {{ userPassword?: string, ownerPassword?: string, permissions?: Record<string, boolean> }} opt
+ */
+export function encryptPdf(doc: import("pdf-lib").PDFDocument, opt: {
+    userPassword?: string;
+    ownerPassword?: string;
+    permissions?: Record<string, boolean>;
+}): Promise<void>;
+/**
+ * The `pdf` option of an API request or the CLI → encryptPdf options, or undefined for no password.
+ * Checks the shape (400 on anything else); the passwords themselves are checked in passwordBytes.
+ * @param {any} pdf { userPassword?, ownerPassword?, permissions?: { print?: boolean, … } }
+ */
+export function pdfEncryptOptions(pdf: any): {
+    userPassword: any;
+    ownerPassword: any;
+    permissions: any;
+};
+export namespace PERMISSION_BITS {
+    let print: number;
+    let modify: number;
+    let copy: number;
+    let annotate: number;
+    let fillForms: number;
+    let accessibility: number;
+    let assemble: number;
+    let printHighQuality: number;
+}

package/dist/types/src/exporters/figures.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The figures of a page, in page order: { tag, items, at, box } (at: index of the first item). A figure's items are
+ * consecutive in the page. One tag id marks one figure, also in a model that went through JSON (a tag copy per item).
+ * @param {any[]} items page items
+ */
+export function figures(items: any[]): any[];
+/** Bounding box of page items (links and bookmarks left out), or null. @param {any[]} items */
+export function boxOf(items: any[]): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+/**
+ * A conservative bounding box of SVG path data: every end and control point, and an arc's end ± its radii.
+ * @param {string} d
+ */
+export function pathBox(d: string): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/**
+ * Text as glyph outlines (SVG path data), where the engine placed it. Plain lines advance by the glyphs' own widths
+ * (as the engine measured them); shaped runs place each glyph by ID.
+ * @param {any} it a text item  @param {(key: string) => any} fontOf fontkit font or null
+ * @returns {string|null} null when a font is missing
+ */
+export function textOutline(it: any, fontOf: (key: string) => any): string | null;
+/**
+ * The SVG of a figure: its items in their own box, text as outlines when the fonts are there.
+ * @param {{ items: any[], box: { x: number, y: number, w: number, h: number } }} fig
+ * @param {{ get: (key: string) => any } | null} [fontStore]
+ */
+export function figureSvg(fig: {
+    items: any[];
+    box: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}, fontStore?: {
+    get: (key: string) => any;
+} | null): string;
+/**
+ * PNG bytes of an SVG, `scale` pixels per point: opt.rasterize when given (the caller's own), else a canvas in a
+ * browser, else sharp in Node (Next.js installs it). Null when none of them is there.
+ * @param {string} svg @param {number} w @param {number} h (points)
+ * @param {{ rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array|null>, scale?: number }} [opt]
+ * @returns {Promise<Uint8Array|null>}
+ */
+export function rasterize(svg: string, w: number, h: number, opt?: {
+    rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array | null>;
+    scale?: number;
+}): Promise<Uint8Array | null>;
+/**
+ * A figure as picture parts: { png?, svg?, jpeg?, w, h, x, y } (where and how big it is drawn, in points). A figure that is one picture (an image item, maybe in a box)
+ * keeps the picture's own bytes; anything else is drawn as SVG and rasterised.
+ * @param {any} fig @param {{ fontStore?: any, fetchImage?: (src: string) => Promise<Uint8Array|null>, rasterize?: any }} opt
+ */
+export function figurePicture(fig: any, opt?: {
+    fontStore?: any;
+    fetchImage?: (src: string) => Promise<Uint8Array | null>;
+    rasterize?: any;
+}): Promise<{
+    [x: string]: any;
+    w: any;
+    h: any;
+    x: any;
+    y: any;
+    svg?: undefined;
+    png?: undefined;
+} | {
+    svg: string;
+    png: Uint8Array<ArrayBufferLike>;
+    w: any;
+    h: any;
+    x: any;
+    y: any;
+}>;
+/** base64 of bytes (Node or browser). @param {Uint8Array} u8 */
+export function b64(u8: Uint8Array): string;
+/**
+ * The box a text item was painted in (paintBox: background rect, the text, its decoration lines, then the border
+ * lines or one rounded border rect), read back from the items around it: { fill, radius, sides: { top, right, bottom, left } }.
+ * @param {any[]} items @param {number} i the text item's index
+ */
+export function boxDecor(items: any[], i: number): {
+    fill: string;
+    radius: number;
+    sides: Record<string, any>;
+};
+/**
+ * The in-cell visuals of the tables on a page (sparklines, data bars, icons that a table cell draws; the engine does
+ * not tag those): shapes inside a table's rows that are not a cell's background. Each becomes a picture in its cell.
+ * Found by position: a visual in a row with no text cell at all is not found (it stays out).
+ * @param {any[]} items @param {Set<number>} used indexes already taken (marked here too)
+ * @param {Map<string, { cells: any[] }>} tables table key → its cell text items (with cell tags and clips)
+ * @returns {Map<string, Map<string, { items: any[], box: any }>>} table key → `${row}|${col}` → the visual
+ */
+export function cellVisuals(items: any[], used: Set<number>, tables: Map<string, {
+    cells: any[];
+}>): Map<string, Map<string, {
+    items: any[];
+    box: any;
+}>>;
+/** Item kinds that are pictures in Word and PowerPoint (a heading tag alone is not). */
+export const FIGURE_KINDS: Set<string>;
+export function hexOrNull(c: any): string;
+export function altOf(tag: any): any;

package/dist/types/src/exporters/html.d.ts

@@ -0,0 +1,24 @@
+/**
+ * One self-contained HTML file: every page as inline SVG, fonts embedded as
+ * base64 (subset when a subsetter is given). URLs open, bookmark jumps and TOC entries scroll to their target, and
+ * drill-through opens the ReportWright viewer at drillBase (without one it is shown disabled).
+ * Unless static, a file whose report has tables also gets a Tables view (htmldata.js): the tables as HTML, re-sorted on
+ * their interactive-sort columns, groups opened and closed, rows filtered, by one inline script the file's CSP allows.
+ * @param {any} model
+ * @param {import('../engine/text/fonts.js').FontStore} fontStore
+ * @param {{ title?: string, drillBase?: string, subset?: (font: Uint8Array, cps: Iterable<number>, o?: { layout?: boolean }) => Promise<Uint8Array>,
+ *   static?: boolean, locale?: string, currency?: string, lang?: string, strings?: Partial<typeof DATA_STRINGS> }} [opt]
+ */
+export function exportHtml(model: any, fontStore: import("../engine/text/fonts.js").FontStore, opt?: {
+    title?: string;
+    drillBase?: string;
+    subset?: (font: Uint8Array, cps: Iterable<number>, o?: {
+        layout?: boolean;
+    }) => Promise<Uint8Array>;
+    static?: boolean;
+    locale?: string;
+    currency?: string;
+    lang?: string;
+    strings?: Partial<typeof DATA_STRINGS>;
+}): any;
+import { DATA_STRINGS } from './htmldata.js';

package/dist/types/src/exporters/htmldata.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The tables of a model as the view's data, or null (no tables, or too many rows).
+ * Each row: { k: kind, l: level, c: [[col, text, key, span]] } (key: a number, or text in lower case, for sorting).
+ * sort: the columns the report sorts on click (its interactive-sort header cells, matched by position).
+ * @param {any} model @param {{ locale?: string, currency?: string }} [o]
+ */
+export function tablesData(model: any, o?: {
+    locale?: string;
+    currency?: string;
+}): {
+    name: string;
+    cols: any;
+    sort: any[];
+    rows: any;
+}[];
+/** sha256 of a text, base64 (a CSP hash). */
+export function cspHash(text: any): Promise<string>;
+/** Most rows a file carries for the Tables view (beyond it, the file stays pages only). */
+export const MAX_DATA_ROWS: 20000;
+export namespace DATA_STRINGS {
+    let pages: string;
+    let tables: string;
+    let all: string;
+    let filter: string;
+    let toggle: string;
+    let sortAsc: string;
+    let sortDesc: string;
+}
+/** The script of the Tables view (a constant: its hash goes in the file's CSP). @type {string} */
+export const DATA_SCRIPT: string;
+/** CSS of the bar and the Tables view. @type {string} */
+export const DATA_CSS: string;

package/dist/types/src/exporters/pdf.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Page model → PDF bytes. Draws exactly the lines the engine made.
+ * @param {any} model  render() output
+ * @param {import('../engine/text/fonts.js').FontStore} fontStore
+ * @param {{ title?: string, author?: string, fetchImage?: (src: string) => Promise<Uint8Array|null>,
+ *   subset?: (font: Uint8Array, codePoints: Iterable<number>) => Promise<Uint8Array>,
+ *   pdfa?: { icc?: Uint8Array }, prepare?: (doc: PDFDocument) => any, save?: object,
+ *   encrypt?: { userPassword?: string, ownerPassword?: string, permissions?: Partial<Record<keyof typeof import('./encrypt.js').PERMISSION_BITS, boolean>> },
+ *   tagged?: { lang?: string }, drillBase?: string, onWarning?: (message: string) => void, timeoutMs?: number,
+ *   creationDate?: Date }} [opt]
+ *   subset: a HarfBuzz subsetter (see subset.js). Without it, fonts embed in full.
+ *   pdfa: make a PDF/A-2b file (needs an sRGB ICC profile). prepare: last change before saving
+ *   (the server adds a signature placeholder there). save: extra pdf-lib save options.
+ *   encrypt: { userPassword, ownerPassword, permissions } — AES-256 (see encrypt.js); not with pdfa or prepare.
+ *   tagged: an accessible PDF (PDF/UA-1, see pdfua.js): structure tree, marked content, artifacts, language, title
+ *   shown; with pdfa it is PDF/A-2a. Off, the file is exactly what it was.
+ *   drillBase: the ReportWright server whose viewer a drill-through opens (a URI link); without it a drill-through
+ *   is not a link. onWarning: what was left out (a damaged image). timeoutMs: the export's time limit (504).
+ *   creationDate: the file's dates (UTC); else SOURCE_DATE_EPOCH when set; with either, the same report exports to the
+ *   same bytes (encryption keeps its random key, so it does not).
+ */
+export function exportPdf(model: any, fontStore: import("../engine/text/fonts.js").FontStore, opt?: {
+    title?: string;
+    author?: string;
+    fetchImage?: (src: string) => Promise<Uint8Array | null>;
+    subset?: (font: Uint8Array, codePoints: Iterable<number>) => Promise<Uint8Array>;
+    pdfa?: {
+        icc?: Uint8Array;
+    };
+    prepare?: (doc: PDFDocument) => any;
+    save?: object;
+    encrypt?: {
+        userPassword?: string;
+        ownerPassword?: string;
+        permissions?: Partial<Record<keyof typeof import("./encrypt.js").PERMISSION_BITS, boolean>>;
+    };
+    tagged?: {
+        lang?: string;
+    };
+    drillBase?: string;
+    onWarning?: (message: string) => void;
+    timeoutMs?: number;
+    creationDate?: Date;
+}): any;
+import { PDFDocument } from 'pdf-lib';

package/dist/types/src/exporters/pdfa.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @param {import('pdf-lib').PDFDocument} doc  call after all pages, fields and annotations are added
+ * @param {{ icc?: Uint8Array, title?: string, author?: string, created?: Date, conformance?: 'A'|'B', ua?: boolean, id?: string }} opt
+ *   id: the file identifier as hex (derived from the content for a fixed date), else random
+ *   icc: an RGB ICC profile (the sRGB one in public/icc). conformance A (PDF/A-2a) for a tagged file; ua: it is PDF/UA-1 too.
+ */
+export function makePdfA(doc: import("pdf-lib").PDFDocument, { icc, title, author, created, conformance, ua, id }?: {
+    icc?: Uint8Array;
+    title?: string;
+    author?: string;
+    created?: Date;
+    conformance?: "A" | "B";
+    ua?: boolean;
+    id?: string;
+}): void;
+/**
+ * The Info dictionary's CreationDate and ModDate for an instant, in UTC (D:…+00'00'): the same instant gives the
+ * same bytes in any time zone. pdf-lib's own setters write the local offset.
+ * @param {import('pdf-lib').PDFDocument} doc
+ * @param {Date} when
+ */
+export function setInfoDates(doc: import("pdf-lib").PDFDocument, when: Date): void;
+/**
+ * PDF/UA-1 without PDF/A: XMP metadata with the title and the PDF/UA identifier (the Info dictionary says the same).
+ * @param {import('pdf-lib').PDFDocument} doc
+ */
+export function setUaMetadata(doc: import("pdf-lib").PDFDocument, { title, author, created }?: {
+    title?: string;
+    author?: any;
+    created?: Date;
+}): void;

package/dist/types/src/exporters/pdfua.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {any} model
+ * @param {import('pdf-lib').PDFDocument} doc
+ */
+export function createTagger(model: any, doc: import("pdf-lib").PDFDocument): {
+    /**
+     * Marked content around item ii of page pi: the operator that opens it, or null (nothing is drawn for it).
+     * @returns {string|null}
+     */
+    open(pi: any, ii: any, it: any): string | null;
+    /** A link annotation of item ii (or a field's widget): its structure element; returns its StructParent key. */
+    annot(pi: any, ii: any, ref: any, kind: any): void;
+    finish({ lang, title }?: {
+        lang?: string;
+        title?: string;
+    }): void;
+};

package/dist/types/src/exporters/png.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Why a PNG cannot be embedded, or null when it can.
+ * @param {Uint8Array} b @returns {string|null}
+ */
+export function pngProblem(b: Uint8Array): string | null;
+export namespace PNG_LIMITS {
+    let pixels: number;
+    let rawBytes: number;
+    let chunks: number;
+}

package/dist/types/src/exporters/pptx.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {any} model render() output
+ * @param {{ title?: string, author?: string, lang?: string, fontStore?: any, fetchImage?: (src: string) => Promise<Uint8Array|null>,
+ *   rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array|null> }} [opt]
+ * @returns {Promise<Uint8Array>}
+ */
+export function exportPptx(model: any, opt?: {
+    title?: string;
+    author?: string;
+    lang?: string;
+    fontStore?: any;
+    fetchImage?: (src: string) => Promise<Uint8Array | null>;
+    rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array | null>;
+}): Promise<Uint8Array>;

package/dist/types/src/exporters/regions.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A page model rendered without exportData (the default: a view, a plain PDF) has no table data and no cell tags:
+ * the exports that rebuild tables refuse it rather than write a file without its tables.
+ */
+export function needsTableData(model: any, what: any): void;
+/** Merge table regions that share a name (a table repeated inside a list). */
+export function mergedRegions(model: any): any[];
+/**
+ * The visual lines of a text item, as strings. A justified line is one run per word on the same
+ * baseline; this joins them back (in x order) so text exports and search see whole lines.
+ * @param {{ lines: { x: number, y: number, text: string }[] }} it
+ * @returns {string[]}
+ */
+export function visualLines(it: {
+    lines: {
+        x: number;
+        y: number;
+        text: string;
+    }[];
+}): string[];
+/**
+ * The visual lines of a page's text items, as strings. Rich text draws one text item per styled
+ * fragment (`rich: {id, l}`); the fragments of one box on one line (superscripts included) are joined in x order with
+ * nothing between them (they keep their own spaces). Other items give their visualLines().
+ * @param {any[]} items page-model items (anything that is not text is skipped)
+ * @returns {string[]}
+ */
+export function textRows(items: any[]): string[];
+export function needsExportData(fmt: any, o?: {}): boolean;
+export function isJustified(it: any): boolean;

package/dist/types/src/exporters/subset.d.ts

@@ -0,0 +1,5 @@
+/** @param {() => Promise<ArrayBuffer|Uint8Array>} loadWasm */
+export function createSubsetter(loadWasm: () => Promise<ArrayBuffer | Uint8Array>): (font: Uint8Array, codePoints: Iterable<number>, opt?: {
+    glyphs?: Iterable<number>;
+    layout?: boolean;
+}) => Promise<Uint8Array>;

package/dist/types/src/exporters/svg.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The address a browser may load an image from, by the policy of the data fetches: a data:image URI or this server's
+ * own path as it is; an absolute http(s) URL only through this server's data proxy (/api/data/proxy: PW_PROXY_ALLOW
+ * hosts, never a private address); anything else (another scheme, //host) not at all. So a stored report cannot make
+ * its viewers' browsers call hosts of its choosing. @param {any} src @param {string} [proxyBase] the server's origin,
+ * for a file opened elsewhere (the HTML export)
+ */
+export function imageHref(src: any, proxyBase?: string): string;
+/**
+ * box: draw only this part of the page (viewBox), as Word and PowerPoint figures do. outline: text as glyph outlines,
+ * from fontkit fonts (figures.js), for readers without the report's fonts.
+ * @param {{ background?: boolean, animate?: boolean, box?: { x: number, y: number, w: number, h: number }, outline?: ((key: string) => any) | null }} [opt]
+ */
+export function pageToSvg(page: any, w: any, h: any, { background, animate, box, outline, proxyBase }?: {
+    background?: boolean;
+    animate?: boolean;
+    box?: any;
+    outline?: any;
+    proxyBase?: string;
+}): string;
+export function linkTitle(a: any): any;
+/** @font-face rules for report fonts served from /fonts (uploaded ones from /fonts/custom). */
+export function fontFaceCss(keys: any, base?: string): any;
+/** Every font key a page model draws with (text items, their runs, form fields). */
+export function fontKeysOf(model: any): any[];
+export function fontFamilyCss(key: any): string;

package/dist/types/src/exporters/svgimage.d.ts

@@ -0,0 +1,33 @@
+/** A transform list, split on ")" and "(": linear, no backtracking. @param {string} s @returns {M} */
+export function parseTransform(s: string): M;
+/**
+ * Shapes of an SVG in its own user space (the root viewBox applied), with their paint resolved.
+ * @param {string} text
+ * @returns {{ w: number, h: number, shapes: { d: string, m: M, fill: any, stroke: any, sw: number, fo: number, so: number }[] } | null}
+ */
+export function parseSvg(text: string): {
+    w: number;
+    h: number;
+    shapes: {
+        d: string;
+        m: M;
+        fill: any;
+        stroke: any;
+        sw: number;
+        fo: number;
+        so: number;
+    }[];
+} | null;
+/**
+ * Draw a parsed SVG into the box (PDF coordinates: x, y of the bottom-left corner), scaled by sx, sy.
+ * @param {any} page pdf-lib PDFPage
+ * @param {NonNullable<ReturnType<typeof parseSvg>>} svg
+ * @param {{ x: number, y: number, sx: number, sy: number }} at
+ */
+export function drawSvg(page: any, svg: NonNullable<ReturnType<typeof parseSvg>>, at: {
+    x: number;
+    y: number;
+    sx: number;
+    sy: number;
+}): void;
+export type M = [number, number, number, number, number, number];

package/dist/types/src/exporters/xlsx.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Report format → Excel number format. value: the cell's value, so a date gets a date format (N6: "d" is a date,
+ * not two decimals) and an en-IN number its own lakh grouping (N22: Excel's conditions cannot cover negatives).
+ * @param {string|null|undefined} fmt @param {string} [currencySymbol] @param {string} [locale] @param {any} [value]
+ */
+export function excelFormat(fmt: string | null | undefined, currencySymbol?: string, locale?: string, value?: any): any;
+/** The currency symbol for a code in the report locale ("INR" → ₹), else the code. */
+export function currencySymbol(iso: any, locale: any): any;
+/** A column's values over the rows a total covers, kept as they pass: what subtotalFn needs, in O(1) memory. */
+export function colStats(): {
+    vals: number;
+    nums: number;
+    sum: number;
+    min: number;
+    max: number;
+    first: any;
+    differ: boolean;
+    /** @param {any} v a region cell's value */
+    add(v: any): void;
+};
+/**
+ * The SUBTOTAL function a total's shown value is, over its column's values (colStats), or null: 9 the sum, 2/3 the
+ * count (COUNTA when there is text), 1 the average, 5 the minimum, 4 the maximum, each within the format's precision.
+ * @param {{ value: any, format?: string }} c @param {ReturnType<typeof colStats>} st
+ */
+export function subtotalFn(c: {
+    value: any;
+    format?: string;
+}, st: ReturnType<typeof colStats>): 1 | 2 | 3 | 4 | 5 | 9;
+/** Excel's sheet names, unique in a workbook: no \\ / ? * [ ] :, no control characters, not starting or ending with ', at
+*  most 31 characters (28 here, room for a " 2"). suffix: kept whole (a split sheet's " (2)"). */
+export function sheetNamer(): (n: any, suffix?: string) => string;
+/** A region cell → an Excel cell: its value (dates as the report's wall clock), number format, bold and header fill. */
+export function xlsxCell({ sym, locale, tz }: {
+    sym: any;
+    locale: any;
+    tz: any;
+}): (c: any, header: boolean) => any;
+/**
+ * Excel workbook in "data mode": one sheet per table, typed cells, number formats,
+ * bold header and group rows, and outline levels for grouped detail rows. Group and table totals that are a sum,
+ * count, average, minimum or maximum of their column are live SUBTOTAL formulas (formulas: false keeps values).
+ * Charts are native Excel charts; pictures go on a sheet of their own (PNG; needs a rasteriser, see figures.js).
+ * Written by xlsxwriter.js (no ExcelJS).
+ * @param {any} model  render() output
+ * @param {{ currency?: string, title?: string, formulas?: boolean, pictures?: boolean, charts?: boolean, fontStore?: any, fonts?: any,
+ *   fetchImage?: (src: string) => Promise<Uint8Array|null>, rasterize?: any, timeZone?: string }} [opt]
+ * @returns {Promise<Uint8Array>}
+ */
+export function exportXlsx(model: any, opt?: {
+    currency?: string;
+    title?: string;
+    formulas?: boolean;
+    pictures?: boolean;
+    charts?: boolean;
+    fontStore?: any;
+    fonts?: any;
+    fetchImage?: (src: string) => Promise<Uint8Array | null>;
+    rasterize?: any;
+    timeZone?: string;
+}, legacy?: any): Promise<Uint8Array>;

package/dist/types/src/exporters/xlsxchart.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The cells a chart's data takes on its sheet, from row 1: a header row, then one row per category (or point).
+ * @param {any} spec items[0].xchart (engine/items/chart.js nativeSpec)
+ * @returns {any[][]}
+ */
+export function chartTable(spec: any): any[][];
+/**
+ * The chart part (xl/charts/chartN.xml) for a spec whose data starts at A1 of `sheet`.
+ * @param {any} spec @param {string} sheet
+ */
+export function chartXml(spec: any, sheet: string): string;
+/**
+ * Add the charts to a workbook ExcelJS wrote. Each chart: { sheet (its sheet's name), spec, at: { col, row } } with
+ * its data at A1 of that sheet; the sheets have no drawing of their own.
+ * @param {Uint8Array} bytes @param {{ sheet: string, spec: any, at: { col: number, row: number } }[]} charts
+ * @returns {Uint8Array}
+ */
+export function addCharts(bytes: Uint8Array, charts: {
+    sheet: string;
+    spec: any;
+    at: {
+        col: number;
+        row: number;
+    };
+}[]): Uint8Array;
+export function esc(s: any): string;