@firestitch/report 18.8.0 → 18.9.0

package/esm2022/app/reports/export/report-text-layout.service.mjs

@@ -0,0 +1,241 @@
+import { ApplicationRef, EnvironmentInjector, Injectable, Injector, afterNextRender, createComponent, inject, } from '@angular/core';
+import { ComponentTextComponent } from '../components/component-text/component-text.component';
+import { PX_PER_INCH } from '../components/report-canvas/report-canvas.component';
+import { componentPaddingCss } from '../layout';
+import { fillTextTokens, parseTable, splitAtTables } from '../text';
+import * as i0 from "@angular/core";
+// How far past the bottom of its box a block may reach and still fit: two
+// pixels, so the rounding of the last line's edge never counts as overflow.
+// The deck keeps a table's row on the same terms.
+export const OVERFLOW_SLACK = 2 / PX_PER_INCH;
+// Where the canvas puts each part of a text block, for the exports. A
+// browser wraps the words and sizes a table's columns by its own layout, which
+// neither jsPDF nor PowerPoint reproduces. So the block is rendered offscreen
+// with the canvas's own component, at the canvas's 96px per inch and unscaled,
+// and the exports place what they draw where it sat: a table at its top, in
+// its column widths and row heights, and the words between tables at theirs.
+// It also tells whether the block runs past the bottom of its box.
+//
+// Provided beside the export services, so the block renders under the same
+// injector the canvas's blocks do.
+export class ReportTextLayoutService {
+    _appRef = inject(ApplicationRef);
+    _environmentInjector = inject(EnvironmentInjector);
+    _injector = inject(Injector);
+    _layouts = new Map();
+    // A block is measured once per size, padding and filled html: an export that
+    // draws it twice, or a second export with the same numbers, reads the same
+    // layout, which nothing changes.
+    async measure(component, tokens) {
+        const html = component.config?.html ?? '';
+        const key = [
+            component.id,
+            component.w,
+            component.h,
+            JSON.stringify(component.config?.padding ?? null),
+            fillTextTokens(html, tokens),
+        ].join('|');
+        let layout = this._layouts.get(key);
+        if (!layout) {
+            layout = this._render(component, html, tokens);
+            this._layouts.set(key, layout);
+            // A measure that failed is tried again next time.
+            layout.catch(() => this._layouts.delete(key));
+        }
+        return layout;
+    }
+    async _render(component, html, tokens) {
+        const text = createComponent(ComponentTextComponent, {
+            environmentInjector: this._environmentInjector,
+            elementInjector: this._injector,
+        });
+        const box = blockBox(component, text.location.nativeElement);
+        try {
+            text.setInput('html', html);
+            text.setInput('tokens', tokens);
+            text.setInput('editing', false);
+            document.body.append(box);
+            await this._rendered(text);
+            // Laid out first, so a font the words ask for is loading by the time
+            // fonts.ready is read.
+            box.getBoundingClientRect();
+            await document.fonts.ready;
+            return measureBlock(text.location.nativeElement.querySelector('.text-content'));
+        }
+        finally {
+            // Destroying the block also takes it off the application.
+            text.destroy();
+            box.remove();
+        }
+    }
+    // The block is rendered by the application's own change detection, as any
+    // view attached to it: its inputs mark it for the next render, which draws
+    // it before the callback runs. Not whenStable(): that also waits out
+    // whatever else the host app has under way (its requests and, under
+    // zone.js, its timers), and never resolves while a timer repeats.
+    _rendered(text) {
+        return new Promise((resolve) => {
+            afterNextRender(() => resolve(), { injector: this._environmentInjector });
+            this._appRef.attachView(text.hostView);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportTextLayoutService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportTextLayoutService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportTextLayoutService, decorators: [{
+            type: Injectable
+        }] });
+// The block's box as the canvas draws it (the component box): its size, a
+// 1px border and the block's padding (componentPaddingCss) around a body the
+// text fills. Fixed far off to the left, and hidden, so it is never seen.
+function blockBox(component, text) {
+    const box = document.createElement('div');
+    const body = document.createElement('div');
+    Object.assign(box.style, {
+        position: 'fixed',
+        left: '-10000px',
+        top: '0',
+        visibility: 'hidden',
+        width: `${component.w * PX_PER_INCH}px`,
+        height: `${component.h * PX_PER_INCH}px`,
+        boxSizing: 'border-box',
+        border: '1px solid transparent',
+        padding: componentPaddingCss(component),
+    });
+    body.style.height = '100%';
+    body.append(text);
+    box.append(body);
+    return box;
+}
+// Split the rendered block at its tables, as textBlocks splits the same html,
+// so the nth segment is the nth text part and the nth table the nth table
+// part. How far the block reaches is the bottom of its last part that draws
+// anything.
+function measureBlock(content) {
+    const box = content.getBoundingClientRect();
+    const parts = splitAtTables(content);
+    const segments = [];
+    const tables = [];
+    let usedHeight = 0;
+    parts.forEach((part, index) => {
+        if (Array.isArray(part)) {
+            const segment = measureSegment(drawnNodes(part, index === parts.length - 1), box);
+            segments.push(segment);
+            usedHeight = segment?.bottom ?? usedHeight;
+        }
+        else {
+            const table = measureTable(part, box);
+            tables.push(table);
+            usedHeight = table.top + table.height;
+        }
+    });
+    const contentHeight = inches(box.height);
+    return {
+        contentWidth: inches(box.width),
+        contentHeight,
+        usedHeight,
+        overflow: usedHeight > contentHeight + OVERFLOW_SLACK,
+        segments,
+        tables,
+    };
+}
+// The nodes of a run between tables that the exports draw. Whitespace between
+// blocks draws nothing anywhere. A blank line at the start of a block is
+// drawn, on the canvas and by textBlocks alike, but textBlocks drops the blank
+// lines at the very end of a block, so they are not measured either: a
+// trailing empty paragraph never makes a block overflow.
+function drawnNodes(nodes, blockEnd) {
+    const skipsLast = blockEnd ? isBlank : isVoid;
+    let start = 0;
+    let end = nodes.length;
+    while (start < end && isVoid(nodes[start])) {
+        start++;
+    }
+    while (end > start && skipsLast(nodes[end - 1])) {
+        end--;
+    }
+    const drawn = nodes.slice(start, end);
+    if (blockEnd && drawn.length) {
+        trimBlankLines(drawn[drawn.length - 1]);
+    }
+    return drawn;
+}
+// Take the blank lines off the end of the block's last node, as textBlocks
+// drops them: the elements that hold no text after its last words, down its
+// last children — the <br>s of <p>b<br><br></p>, a list's empty last item.
+// Whitespace is passed over and left, so a paragraph never turns into an
+// empty one, which the canvas draws as a line. The block is the measure's own
+// copy, thrown away once measured, and nothing above what is taken off moves.
+function trimBlankLines(node) {
+    let child = node.lastChild;
+    while (child && isBlank(child)) {
+        const previous = child.previousSibling;
+        if (!isVoid(child)) {
+            child.remove();
+        }
+        child = previous;
+    }
+    if (child) {
+        trimBlankLines(child);
+    }
+}
+// Whitespace between blocks, or a comment.
+function isVoid(node) {
+    return node.nodeType === Node.TEXT_NODE
+        ? !/[^ \t\n\r\f]/.test(node.textContent ?? '')
+        : node.nodeType !== Node.ELEMENT_NODE;
+}
+// A node that draws no words: whitespace, or an element with no text in it,
+// such as the empty line <p><br></p>.
+function isBlank(node) {
+    return isVoid(node) || !node.textContent;
+}
+// From before its first node to after its last. null for a run that draws
+// nothing.
+function measureSegment(nodes, box) {
+    if (!nodes.length) {
+        return null;
+    }
+    const range = document.createRange();
+    range.setStartBefore(nodes[0]);
+    range.setEndAfter(nodes[nodes.length - 1]);
+    const rect = range.getBoundingClientRect();
+    return { top: inches(rect.top - box.top), bottom: inches(rect.bottom - box.top) };
+}
+function measureTable(table, box) {
+    const rect = table.getBoundingClientRect();
+    return {
+        top: inches(rect.top - box.top),
+        left: inches(rect.left - box.left),
+        width: inches(rect.width),
+        height: inches(rect.height),
+        rowHeights: Array.from(table.rows, (row) => inches(row.getBoundingClientRect().height)),
+        columnWidths: columnWidths(table, rect.width).map(inches),
+    };
+}
+// A grid column is as wide as a cell that spans only it. A column that only
+// spanning cells cross shares what the others leave of the table's width, and
+// all of them are scaled to add up to it exactly. The cells come in the same
+// order as the grid's (parseTable reads the same rows), so the nth cell of a
+// row is the nth cell of that grid row.
+function columnWidths(table, width) {
+    const grid = parseTable(table);
+    const widths = Array.from({ length: grid.columns }, () => null);
+    grid.rows.forEach((row, rowIndex) => row.cells.forEach((cell, cellIndex) => {
+        if (cell.colSpan === 1 && widths[cell.column] === null) {
+            widths[cell.column] = table.rows[rowIndex].cells[cellIndex].getBoundingClientRect().width;
+        }
+    }));
+    const known = widths.filter((value) => value !== null);
+    const share = Math.max(0, width - sum(known)) / Math.max(1, widths.length - known.length);
+    const filled = widths.map((value) => value ?? share);
+    const total = sum(filled);
+    return filled.map((value) => total ? value * width / total : width / filled.length);
+}
+function sum(values) {
+    return values.reduce((total, value) => total + value, 0);
+}
+function inches(pixels) {
+    return pixels / PX_PER_INCH;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-text-layout.service.js","sourceRoot":"","sources":["../../../../../src/app/reports/export/report-text-layout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApplicationRef, ComponentRef, EnvironmentInjector, Injectable, Injector, afterNextRender, createComponent, inject,\n} from '@angular/core';\n\nimport { ComponentTextComponent } from '../components/component-text/component-text.component';\nimport { PX_PER_INCH } from '../components/report-canvas/report-canvas.component';\nimport { ReportComponent } from '../interfaces/report.interface';\nimport { componentPaddingCss } from '../layout';\nimport { TextTokenContext, fillTextTokens, parseTable, splitAtTables } from '../text';\n\n\n// Where a stretch of a block's words sits: the top of its first line and the\n// bottom of its last.\nexport interface TextSegmentLayout {\n  top: number;\n  bottom: number;\n}\n\n// Where a table sits in its block, and how tall its rows and how wide its\n// columns are.\nexport interface TextTableLayout {\n  top: number;\n  left: number;\n  width: number;\n  height: number;\n  // A row's height, in the order textBlocks lists the rows: the head first and\n  // the foot last.\n  rowHeights: number[];\n  // A grid column's width (tableGrid), left to right. Together they are the\n  // table's width.\n  columnWidths: number[];\n}\n\n// A text block as the canvas lays it out. Everything is in inches, measured\n// from the top left of the block's content box (inside its padding).\nexport interface TextBlockLayout {\n  contentWidth: number;\n  contentHeight: number;\n  // How far down the block's words and tables reach.\n  usedHeight: number;\n  // They reach past the bottom of the box, where the canvas cuts them off.\n  overflow: boolean;\n  // One per text part of textBlocks, in order: null for a part that draws\n  // nothing.\n  segments: (TextSegmentLayout | null)[];\n  // One per table part of textBlocks, in order.\n  tables: TextTableLayout[];\n}\n\n// How far past the bottom of its box a block may reach and still fit: two\n// pixels, so the rounding of the last line's edge never counts as overflow.\n// The deck keeps a table's row on the same terms.\nexport const OVERFLOW_SLACK = 2 / PX_PER_INCH;\n\n// Where the canvas puts each part of a text block, for the exports. A\n// browser wraps the words and sizes a table's columns by its own layout, which\n// neither jsPDF nor PowerPoint reproduces. So the block is rendered offscreen\n// with the canvas's own component, at the canvas's 96px per inch and unscaled,\n// and the exports place what they draw where it sat: a table at its top, in\n// its column widths and row heights, and the words between tables at theirs.\n// It also tells whether the block runs past the bottom of its box.\n//\n// Provided beside the export services, so the block renders under the same\n// injector the canvas's blocks do.\n@Injectable()\nexport class ReportTextLayoutService {\n\n  private readonly _appRef = inject(ApplicationRef);\n  private readonly _environmentInjector = inject(EnvironmentInjector);\n  private readonly _injector = inject(Injector);\n  private readonly _layouts = new Map<string, Promise<TextBlockLayout>>();\n\n  // A block is measured once per size, padding and filled html: an export that\n  // draws it twice, or a second export with the same numbers, reads the same\n  // layout, which nothing changes.\n  public async measure(component: ReportComponent, tokens: TextTokenContext): Promise<TextBlockLayout> {\n    const html = component.config?.html ?? '';\n    const key = [\n      component.id,\n      component.w,\n      component.h,\n      JSON.stringify(component.config?.padding ?? null),\n      fillTextTokens(html, tokens),\n    ].join('|');\n\n    let layout = this._layouts.get(key);\n    if (!layout) {\n      layout = this._render(component, html, tokens);\n      this._layouts.set(key, layout);\n      // A measure that failed is tried again next time.\n      layout.catch(() => this._layouts.delete(key));\n    }\n\n    return layout;\n  }\n\n  private async _render(component: ReportComponent, html: string, tokens: TextTokenContext): Promise<TextBlockLayout> {\n    const text = createComponent(ComponentTextComponent, {\n      environmentInjector: this._environmentInjector,\n      elementInjector: this._injector,\n    });\n    const box = blockBox(component, text.location.nativeElement);\n\n    try {\n      text.setInput('html', html);\n      text.setInput('tokens', tokens);\n      text.setInput('editing', false);\n      document.body.append(box);\n      await this._rendered(text);\n      // Laid out first, so a font the words ask for is loading by the time\n      // fonts.ready is read.\n      box.getBoundingClientRect();\n      await document.fonts.ready;\n\n      return measureBlock(text.location.nativeElement.querySelector('.text-content'));\n    } finally {\n      // Destroying the block also takes it off the application.\n      text.destroy();\n      box.remove();\n    }\n  }\n\n  // The block is rendered by the application's own change detection, as any\n  // view attached to it: its inputs mark it for the next render, which draws\n  // it before the callback runs. Not whenStable(): that also waits out\n  // whatever else the host app has under way (its requests and, under\n  // zone.js, its timers), and never resolves while a timer repeats.\n  private _rendered(text: ComponentRef<ComponentTextComponent>): Promise<void> {\n    return new Promise((resolve) => {\n      afterNextRender(() => resolve(), { injector: this._environmentInjector });\n      this._appRef.attachView(text.hostView);\n    });\n  }\n}\n\n// The block's box as the canvas draws it (the component box): its size, a\n// 1px border and the block's padding (componentPaddingCss) around a body the\n// text fills. Fixed far off to the left, and hidden, so it is never seen.\nfunction blockBox(component: ReportComponent, text: HTMLElement): HTMLElement {\n  const box = document.createElement('div');\n  const body = document.createElement('div');\n\n  Object.assign(box.style, {\n    position: 'fixed',\n    left: '-10000px',\n    top: '0',\n    visibility: 'hidden',\n    width: `${component.w * PX_PER_INCH}px`,\n    height: `${component.h * PX_PER_INCH}px`,\n    boxSizing: 'border-box',\n    border: '1px solid transparent',\n    padding: componentPaddingCss(component),\n  });\n  body.style.height = '100%';\n  body.append(text);\n  box.append(body);\n\n  return box;\n}\n\n// Split the rendered block at its tables, as textBlocks splits the same html,\n// so the nth segment is the nth text part and the nth table the nth table\n// part. How far the block reaches is the bottom of its last part that draws\n// anything.\nfunction measureBlock(content: HTMLElement): TextBlockLayout {\n  const box = content.getBoundingClientRect();\n  const parts = splitAtTables(content);\n  const segments: (TextSegmentLayout | null)[] = [];\n  const tables: TextTableLayout[] = [];\n  let usedHeight = 0;\n\n  parts.forEach((part, index) => {\n    if (Array.isArray(part)) {\n      const segment = measureSegment(drawnNodes(part, index === parts.length - 1), box);\n      segments.push(segment);\n      usedHeight = segment?.bottom ?? usedHeight;\n    } else {\n      const table = measureTable(part, box);\n      tables.push(table);\n      usedHeight = table.top + table.height;\n    }\n  });\n\n  const contentHeight = inches(box.height);\n\n  return {\n    contentWidth: inches(box.width),\n    contentHeight,\n    usedHeight,\n    overflow: usedHeight > contentHeight + OVERFLOW_SLACK,\n    segments,\n    tables,\n  };\n}\n\n// The nodes of a run between tables that the exports draw. Whitespace between\n// blocks draws nothing anywhere. A blank line at the start of a block is\n// drawn, on the canvas and by textBlocks alike, but textBlocks drops the blank\n// lines at the very end of a block, so they are not measured either: a\n// trailing empty paragraph never makes a block overflow.\nfunction drawnNodes(nodes: Node[], blockEnd: boolean): Node[] {\n  const skipsLast = blockEnd ? isBlank : isVoid;\n  let start = 0;\n  let end = nodes.length;\n\n  while (start < end && isVoid(nodes[start])) {\n    start++;\n  }\n  while (end > start && skipsLast(nodes[end - 1])) {\n    end--;\n  }\n\n  const drawn = nodes.slice(start, end);\n  if (blockEnd && drawn.length) {\n    trimBlankLines(drawn[drawn.length - 1]);\n  }\n\n  return drawn;\n}\n\n// Take the blank lines off the end of the block's last node, as textBlocks\n// drops them: the elements that hold no text after its last words, down its\n// last children — the <br>s of <p>b<br><br></p>, a list's empty last item.\n// Whitespace is passed over and left, so a paragraph never turns into an\n// empty one, which the canvas draws as a line. The block is the measure's own\n// copy, thrown away once measured, and nothing above what is taken off moves.\nfunction trimBlankLines(node: Node): void {\n  let child = node.lastChild;\n  while (child && isBlank(child)) {\n    const previous = child.previousSibling;\n    if (!isVoid(child)) {\n      child.remove();\n    }\n    child = previous;\n  }\n\n  if (child) {\n    trimBlankLines(child);\n  }\n}\n\n// Whitespace between blocks, or a comment.\nfunction isVoid(node: Node): boolean {\n  return node.nodeType === Node.TEXT_NODE\n    ? !/[^ \\t\\n\\r\\f]/.test(node.textContent ?? '')\n    : node.nodeType !== Node.ELEMENT_NODE;\n}\n\n// A node that draws no words: whitespace, or an element with no text in it,\n// such as the empty line <p><br></p>.\nfunction isBlank(node: Node): boolean {\n  return isVoid(node) || !node.textContent;\n}\n\n// From before its first node to after its last. null for a run that draws\n// nothing.\nfunction measureSegment(nodes: Node[], box: DOMRect): TextSegmentLayout | null {\n  if (!nodes.length) {\n    return null;\n  }\n\n  const range = document.createRange();\n  range.setStartBefore(nodes[0]);\n  range.setEndAfter(nodes[nodes.length - 1]);\n  const rect = range.getBoundingClientRect();\n\n  return { top: inches(rect.top - box.top), bottom: inches(rect.bottom - box.top) };\n}\n\nfunction measureTable(table: HTMLTableElement, box: DOMRect): TextTableLayout {\n  const rect = table.getBoundingClientRect();\n\n  return {\n    top: inches(rect.top - box.top),\n    left: inches(rect.left - box.left),\n    width: inches(rect.width),\n    height: inches(rect.height),\n    rowHeights: Array.from(table.rows, (row) => inches(row.getBoundingClientRect().height)),\n    columnWidths: columnWidths(table, rect.width).map(inches),\n  };\n}\n\n// A grid column is as wide as a cell that spans only it. A column that only\n// spanning cells cross shares what the others leave of the table's width, and\n// all of them are scaled to add up to it exactly. The cells come in the same\n// order as the grid's (parseTable reads the same rows), so the nth cell of a\n// row is the nth cell of that grid row.\nfunction columnWidths(table: HTMLTableElement, width: number): number[] {\n  const grid = parseTable(table);\n  const widths: (number | null)[] = Array.from({ length: grid.columns }, () => null);\n\n  grid.rows.forEach((row, rowIndex) => row.cells.forEach((cell, cellIndex) => {\n    if (cell.colSpan === 1 && widths[cell.column] === null) {\n      widths[cell.column] = table.rows[rowIndex].cells[cellIndex].getBoundingClientRect().width;\n    }\n  }));\n\n  const known = widths.filter((value): value is number => value !== null);\n  const share = Math.max(0, width - sum(known)) / Math.max(1, widths.length - known.length);\n  const filled = widths.map((value) => value ?? share);\n  const total = sum(filled);\n\n  return filled.map((value) => total ? value * width / total : width / filled.length);\n}\n\nfunction sum(values: number[]): number {\n  return values.reduce((total, value) => total + value, 0);\n}\n\nfunction inches(pixels: number): number {\n  return pixels / PX_PER_INCH;\n}\n"]}