@docx4j/core-ts 0.5.0 → 0.7.0

package/dist/model/text/PlainText.mjs

@@ -0,0 +1,542 @@
+import { CaseMapping } from './CaseMapping.mjs';
+/** The spaces for each 720-twip tab stop of indent under `layout: indent` (REQ-709). */
+export const INDENT_SPACES = 4;
+/** The note line before a table in the listed format (REQ-605, REQ-707). */
+export const LISTED_FORMAT_NOTE = '[table: listed format]';
+/**
+ * Plain text from the block model (WD section 7.1): each paragraph one line, a break one line more
+ * (REQ-603); the text exactly as the document holds it (REQ-602), U+000A between lines and after the last.
+ *
+ * Tables (REQ-605): a simple table a row a line, its cells a tab apart; any other in the listed format,
+ * after the note line `[table: listed format]`, a row a line as `Header: value; Header: value`. `tables:
+ * tsv` writes every table in the simple form, `tables: grid` as a pandoc grid table, its spans drawn.
+ *
+ * What the extractor adds follows the WD's bracket convention (REQ-707): `[n]` at a note's reference and
+ * at the start of the note; `[image: ...]` (or `[image, generated: ...]`) under `alt_text: true`; `[page
+ * n]` under `page_markers: true`; and under `metadata: true`, before the body, one line per kind of
+ * property that has any (REQ-515). In the markup view, insertions are `{++text++}`, deletions `{--text--}`
+ * and comments `{>>text<<}`, at their references with their replies after them (REQ-702, REQ-504); under
+ * `markup_detail` the marker's opening is followed by `author:` or `author, date:`.
+ *
+ * Under `layout: indent` (REQ-709) a paragraph outside a table begins with four spaces for each tab stop
+ * (720 twips) of its first line's indent, rounded to the nearest stop. docx4j `PlainText`.
+ */
+export const PlainText = {
+    /** The plain text of a result. */
+    of(result) {
+        const w = new Writer(result);
+        if (result.options.metadata)
+            w.metadata(result.metadata);
+        for (const block of result.blocks) {
+            w.top(block);
+            w.out += '\n';
+        }
+        return w.out;
+    },
+    /** Whether a table is written in REQ-605's simple form under `tables: auto`. */
+    isSimple(table) {
+        return isSimple(table);
+    },
+};
+/**
+ * No merged or split cells, no nested table, one paragraph a cell. A cell is merged or split when it
+ * crosses a column edge another row has, or is in a vertical merge; a cell spanning grid columns that
+ * every row spans alike merges nothing. A cell's empty paragraphs don't count.
+ */
+function isSimple(table) {
+    let edgesBefore;
+    for (const row of table.rows) {
+        const own = [...edges(row)].join(',');
+        if (edgesBefore !== undefined && edgesBefore !== own)
+            return false;
+        edgesBefore = own;
+        for (const cell of row.cells) {
+            if (cell.mergeContinue || cell.mergeRestart)
+                return false;
+            let paragraphs = 0;
+            for (const b of cell.blocks) {
+                if (b.kind !== 'PARAGRAPH')
+                    return false;
+                if (b.runs.length > 0 || b.listLabel !== undefined)
+                    paragraphs++;
+            }
+            if (paragraphs > 1)
+                return false;
+        }
+    }
+    return true;
+}
+/** A row's cell edges in grid columns, by gridSpan: 0, and each cell's end. */
+function edges(row) {
+    const out = new Set([0]);
+    let col = 0;
+    for (const c of row.cells)
+        out.add((col += Math.max(1, c.gridSpan)));
+    return out;
+}
+/** The grid columns each cell of a row starts at, by gridSpan. */
+function starts(row) {
+    const out = [];
+    let col = 0;
+    for (const c of row.cells) {
+        out.push(col);
+        col += Math.max(1, c.gridSpan);
+    }
+    return out;
+}
+/** The header rows: those marked `w:tblHeader`, else the first. */
+function headerRows(rows) {
+    let n = 0;
+    while (n < rows.length && rows[n].header)
+        n++;
+    return n > 0 ? n : Math.min(1, rows.length);
+}
+/** The grid's width: the most grid columns a row spans. */
+function width(rows) {
+    let w = 0;
+    for (const row of rows)
+        w = Math.max(w, row.cells.reduce((n, c) => n + Math.max(1, c.gridSpan), 0));
+    return w;
+}
+/** A row of one cell spanning every grid column: a title, or a divider such as "Part A". */
+function fullWidth(row, gridWidth) {
+    return row.cells.length === 1 && Math.max(1, row.cells[0].gridSpan) === gridWidth;
+}
+/** The first header with text over a cell's grid columns. */
+function header(headers, start, span) {
+    for (let g = start; g < start + span; g++) {
+        const h = headers.get(g);
+        if (h !== undefined && h !== '')
+            return h;
+    }
+    return undefined;
+}
+function label(head, value) {
+    return head === undefined || head === '' ? value : `${head}: ${value}`;
+}
+class Writer {
+    constructor(result) {
+        this.result = result;
+        this.out = '';
+        this.options = result.options;
+    }
+    // --- the metadata block (REQ-515) ---------------------------------------------------------------
+    metadata(metadata) {
+        this.group('core properties', metadata.core);
+        this.group('application properties', metadata.app);
+        this.group('custom properties', metadata.custom);
+    }
+    group(name, properties) {
+        if (typeof properties !== 'object' || properties === null)
+            return;
+        const entries = Object.entries(properties);
+        if (entries.length === 0)
+            return;
+        this.out += `[${name}: ${entries.map(([k, v]) => `${k}: ${String(v)}`).join('; ')}]\n`;
+    }
+    // --- blocks -----------------------------------------------------------------------------------
+    /** A block of the story: a paragraph with its indent, a table, a chart. */
+    top(block) {
+        if (block.kind === 'PARAGRAPH' && this.options.layout === 'indent')
+            this.indent(block);
+        this.block(block);
+    }
+    indent(block) {
+        var _a, _b, _c;
+        const twips = ((_a = block.indentLeft) !== null && _a !== void 0 ? _a : 0) + ((_b = block.indentFirstLine) !== null && _b !== void 0 ? _b : 0) - ((_c = block.indentHanging) !== null && _c !== void 0 ? _c : 0);
+        const stops = Math.round(twips / 720); // Java's Math.round: half up
+        for (let i = 0; i < stops * INDENT_SPACES; i++)
+            this.out += ' ';
+    }
+    block(block) {
+        if (block.kind === 'TABLE')
+            this.table(block);
+        else if (block.kind === 'CHART')
+            this.chart(block);
+        else
+            this.paragraph(block);
+    }
+    chart(block) {
+        let any = false;
+        if (block.chart) {
+            this.out += block.chart.note;
+            any = true;
+        }
+        if (block.chartTitle) {
+            if (any)
+                this.out += '\n';
+            this.out += block.chartTitle;
+            any = true;
+        }
+        const lines = [];
+        if (block.chartHeader.length > 0)
+            lines.push(block.chartHeader);
+        lines.push(...block.chartRows);
+        for (const line of lines) {
+            if (any)
+                this.out += '\n';
+            this.out += line.join('\t');
+            any = true;
+        }
+    }
+    paragraph(block) {
+        if (block.listLabel !== undefined)
+            this.out += block.listLabel;
+        const runs = block.runs;
+        let i = 0;
+        while (i < runs.length) {
+            const revision = runs[i].revision;
+            let j = i;
+            while (j < runs.length && this.sameMarker(revision, runs[j].revision))
+                j++;
+            if (revision) {
+                this.out += revision.type === 'INSERTION' ? '{++' : '{--';
+                this.detail(revision.author, revision.date);
+            }
+            for (let k = i; k < j; k++)
+                this.run(runs[k]);
+            if (revision)
+                this.out += revision.type === 'INSERTION' ? '++}' : '--}';
+            i = j;
+        }
+    }
+    /** Runs under one marker: the same type, and the same author and date where the detail shows them. */
+    sameMarker(a, b) {
+        if (a === undefined || b === undefined)
+            return a === b;
+        if (a.type !== b.type)
+            return false;
+        switch (this.options.markupDetail) {
+            case 'author': return a.author === b.author;
+            case 'author_date': return a.author === b.author && a.date === b.date;
+            default: return true;
+        }
+    }
+    detail(author, date) {
+        switch (this.options.markupDetail) {
+            case 'author':
+                this.out += `${author !== null && author !== void 0 ? author : ''}: `;
+                break;
+            case 'author_date':
+                this.out += `${author !== null && author !== void 0 ? author : ''}${date === undefined ? '' : `, ${date}`}: `;
+                break; // a mark with no date: its author alone (REQ-702)
+            default:
+        }
+    }
+    run(run) {
+        switch (run.kind) {
+            case 'TEXT': // w:caps in capitals, by the run's language (REQ-607)
+                this.out += CaseMapping.written(run, this.options);
+                break;
+            case 'FIELD_CODE':
+            case 'LIST_LABEL':
+                this.out += run.text;
+                break;
+            case 'NOTE_REFERENCE':
+                if (this.options.noteReferences && this.options.notes && run.noteNumber > 0)
+                    this.out += `[${run.noteNumber}]`;
+                break;
+            case 'NOTE_MARK':
+                if (run.noteNumber > 0)
+                    this.out += `[${run.noteNumber}]`;
+                break;
+            case 'COMMENT_REFERENCE': {
+                const comment = run.commentId === undefined ? undefined : this.result.comments.get(run.commentId);
+                if (!comment || (comment.parentId !== undefined && this.result.comments.has(comment.parentId)))
+                    break;
+                this.comment(comment);
+                for (const reply of comment.replies)
+                    this.comment(reply);
+                break;
+            }
+            case 'IMAGE': {
+                const d = run.description;
+                if (!this.options.altText || !d)
+                    break;
+                this.out += `${d.provenance === 'GENERATED' ? '[image, generated: ' : '[image: '}${d.text}]`;
+                break;
+            }
+            case 'PAGE_MARKER':
+                if (this.options.pageMarkers)
+                    this.out += `[page ${run.pageNumber}]`;
+                break;
+            default:
+        }
+    }
+    comment(comment) {
+        this.out += '{>>';
+        this.detail(comment.author, comment.date);
+        this.out += `${CaseMapping.written(comment, this.options)}<<}`;
+    }
+    /** A block written on its own, for a table cell's value. */
+    text(block) {
+        const saved = this.out;
+        this.out = '';
+        try {
+            this.block(block);
+            return this.out;
+        }
+        finally {
+            this.out = saved;
+        }
+    }
+    // --- tables (REQ-605) -------------------------------------------------------------------------
+    table(table) {
+        let form = this.options.tables;
+        if (table.simpleForm)
+            form = 'tsv';
+        if (form === 'grid')
+            this.grid(table);
+        else if (form === 'tsv' || isSimple(table))
+            this.tabSeparated(table);
+        else
+            this.listed(table);
+    }
+    tabSeparated(table) {
+        const rows = table.rows;
+        for (let r = 0; r < rows.length; r++) {
+            if (r > 0)
+                this.out += '\n';
+            const cells = rows[r].cells;
+            for (let c = 0; c < cells.length; c++) {
+                if (c > 0)
+                    this.out += '\t';
+                this.out += this.values(cells[c]).join(' ');
+            }
+        }
+    }
+    /**
+     * The listed format (REQ-605). Every cell is labelled by the header over its first grid column, or the
+     * first of its columns' headers that has text; several header rows' texts are joined ` / `; a cell under
+     * a header with no text is its value alone. A row whose one cell spans every grid column is that cell's
+     * text alone, and labels nothing. A cell with no value is left out; a vertical merge's value is on every
+     * row it covers. Labelled cells are `; ` apart; in a table with no labels cells are a tab apart.
+     */
+    listed(table) {
+        var _a;
+        this.out += LISTED_FORMAT_NOTE;
+        const rows = table.rows;
+        const gridWidth = width(rows);
+        const headerCount = headerRows(rows);
+        // a table of header rows only is written unlabelled, its rows as body rows
+        const headersOnly = headerCount >= rows.length;
+        const headers = new Map();
+        if (!headersOnly) {
+            for (let r = 0; r < headerCount; r++) {
+                const row = rows[r];
+                if (fullWidth(row, gridWidth)) {
+                    const text = this.value(row.cells[0]);
+                    if (text !== '')
+                        this.out += `\n${text}`;
+                    continue;
+                }
+                const at = starts(row);
+                for (let c = 0; c < at.length; c++) {
+                    const cell = row.cells[c];
+                    const text = this.value(cell);
+                    if (text === '')
+                        continue;
+                    for (let g = at[c]; g < at[c] + Math.max(1, cell.gridSpan); g++) {
+                        const h = headers.get(g);
+                        headers.set(g, h === undefined ? text : `${h} / ${text}`);
+                    }
+                }
+            }
+        }
+        const labelled = headers.size > 0;
+        const body = headersOnly ? rows : rows.slice(headerCount);
+        const restarts = new Map();
+        for (const row of body) {
+            this.out += '\n';
+            if (fullWidth(row, gridWidth)) {
+                this.out += this.value(row.cells[0]);
+                continue;
+            }
+            const at = starts(row);
+            const parts = [];
+            for (let c = 0; c < at.length; c++) {
+                const cell = row.cells[c];
+                let value;
+                if (cell.mergeContinue) {
+                    value = (_a = restarts.get(at[c])) !== null && _a !== void 0 ? _a : '';
+                }
+                else {
+                    value = this.value(cell);
+                    if (cell.mergeRestart)
+                        restarts.set(at[c], value);
+                }
+                if (value === '')
+                    continue;
+                parts.push(labelled ? label(header(headers, at[c], Math.max(1, cell.gridSpan)), value) : value);
+            }
+            this.out += parts.join(labelled ? '; ' : '\t');
+        }
+    }
+    /** A cell's paragraphs, a nested table's included, `; ` apart, empty ones left out. */
+    value(cell) {
+        return this.values(cell).join('; ');
+    }
+    values(cell, out = []) {
+        for (const b of cell.blocks) {
+            if (b.kind === 'TABLE') {
+                for (const r of b.rows)
+                    for (const c of r.cells)
+                        this.values(c, out);
+            }
+            else {
+                const s = this.text(b);
+                if (s !== '')
+                    out.push(s);
+            }
+        }
+        return out;
+    }
+    // --- pandoc grid tables -----------------------------------------------------------------------
+    grid(table) {
+        for (const line of this.gridLines(table)) {
+            if (this.out.length > 0 && !this.out.endsWith('\n'))
+                this.out += '\n';
+            this.out += line;
+        }
+    }
+    gridLines(table) {
+        var _a;
+        const rows = table.rows;
+        const placed = [];
+        const at = [];
+        // the grid's columns are those some row's cell edges mark, so a span every row shares draws as one column
+        const union = new Set();
+        for (const row of rows)
+            for (const e of edges(row))
+                union.add(e);
+        const edgeList = [...union].sort((a, b) => a - b);
+        const columns = edgeList.length - 1;
+        if (columns <= 0)
+            return [];
+        const open = new Map();
+        for (let r = 0; r < rows.length; r++) {
+            at[r] = new Array(columns).fill(undefined);
+            const row = rows[r];
+            const begin = starts(row);
+            for (let c = 0; c < begin.length; c++) {
+                const cell = row.cells[c];
+                const first = edgeList.indexOf(begin[c]);
+                const span = edgeList.indexOf(begin[c] + Math.max(1, cell.gridSpan)) - first;
+                let p;
+                const opened = open.get(first);
+                if (cell.mergeContinue && opened !== undefined && opened.span === span) {
+                    p = opened;
+                    p.rowSpan++;
+                }
+                else {
+                    p = { row: r, col: first, span, rowSpan: 1, lines: this.cellLines(cell) };
+                    placed.push(p);
+                    if (cell.mergeRestart)
+                        open.set(first, p);
+                    else
+                        open.delete(first);
+                }
+                for (let g = first; g < first + span && g < columns; g++)
+                    at[r][g] = p;
+            }
+        }
+        // column widths: single-column cells first, then spans widen their last column
+        const widths = new Array(columns).fill(3);
+        for (const p of placed)
+            if (p.span === 1)
+                for (const l of p.lines)
+                    widths[p.col] = Math.max(widths[p.col], l.length);
+        for (const p of placed) {
+            if (p.span === 1)
+                continue;
+            const last = Math.min(columns, p.col + p.span) - 1;
+            let have = 0;
+            for (let g = p.col; g <= last; g++)
+                have += widths[g];
+            have += 3 * (last - p.col);
+            for (const l of p.lines)
+                if (l.length > have) {
+                    widths[last] = widths[last] + (l.length - have);
+                    have = l.length;
+                }
+        }
+        // row heights: a cell's lines over the rows it spans
+        const heights = new Array(rows.length).fill(1);
+        for (const p of placed)
+            if (p.rowSpan === 1)
+                heights[p.row] = Math.max(heights[p.row], p.lines.length);
+        for (const p of placed) {
+            if (p.rowSpan === 1)
+                continue;
+            let have = 0;
+            for (let r = p.row; r < p.row + p.rowSpan; r++)
+                have += heights[r];
+            if (p.lines.length > have)
+                heights[p.row + p.rowSpan - 1] = heights[p.row + p.rowSpan - 1] + (p.lines.length - have);
+        }
+        const headerCount = rows.length > 1 ? headerRows(rows) : 0;
+        const out = [border(undefined, at[0], widths, '-')];
+        const written = new Map();
+        for (let r = 0; r < rows.length; r++) {
+            for (let line = 0; line < heights[r]; line++) {
+                let l = '|';
+                let g = 0;
+                while (g < columns) {
+                    const p = at[r][g];
+                    const span = p === undefined ? 1 : Math.min(p.span, columns - g);
+                    let w = 0;
+                    for (let k = g; k < g + span; k++)
+                        w += widths[k];
+                    w += 3 * (span - 1);
+                    let text = '';
+                    if (p) {
+                        const n = (_a = written.get(p)) !== null && _a !== void 0 ? _a : 0;
+                        if (n < p.lines.length)
+                            text = p.lines[n];
+                        written.set(p, n + 1);
+                    }
+                    l += ` ${text}${' '.repeat(Math.max(0, w - text.length))} |`;
+                    g += span;
+                }
+                out.push(l);
+            }
+            if (r < rows.length - 1)
+                out.push(border(at[r], at[r + 1], widths, r === headerCount - 1 ? '=' : '-'));
+        }
+        out.push(border(at[rows.length - 1], undefined, widths, '-'));
+        return out;
+    }
+    /** A cell's lines: each paragraph's lines, a blank line between paragraphs, a nested table drawn as a grid. */
+    cellLines(cell) {
+        const lines = [];
+        for (const b of cell.blocks) {
+            let own;
+            if (b.kind === 'TABLE') {
+                own = this.gridLines(b);
+            }
+            else {
+                const s = this.text(b);
+                if (s === '')
+                    continue;
+                own = s.split('\n');
+            }
+            if (lines.length > 0)
+                lines.push('');
+            lines.push(...own);
+        }
+        return lines;
+    }
+}
+/** The border between two rows: open where a cell spans both. */
+function border(above, below, widths, fill) {
+    let l = '';
+    for (let g = 0; g < widths.length; g++) {
+        const through = above !== undefined && below !== undefined && above[g] !== undefined && above[g] === below[g];
+        const joinLeft = g > 0 && through && above[g - 1] === above[g];
+        l += g === 0 ? (through ? '|' : '+') : joinLeft ? ' ' : '+';
+        l += (through ? ' ' : fill).repeat(widths[g] + 2);
+    }
+    const lastColumn = widths.length - 1;
+    const throughLast = above !== undefined && below !== undefined && above[lastColumn] !== undefined && above[lastColumn] === below[lastColumn];
+    return l + (throughLast ? '|' : '+');
+}