wikiparser-node 1.13.1-b → 1.13.1

package/dist/src/table/index.js

@@ -0,0 +1,506 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableToken = exports.Layout = exports.isRowEnd = void 0;
+const lint_1 = require("../../util/lint");
+const debug_1 = require("../../util/debug");
+const rect_1 = require("../../lib/rect");
+const index_1 = require("../../index");
+const trBase_1 = require("./trBase");
+const syntax_1 = require("../syntax");
+/* NOT FOR BROWSER */
+const html_1 = require("../../util/html");
+const constants_1 = require("../../util/constants");
+const string_1 = require("../../util/string");
+/* NOT FOR BROWSER END */
+const closingPattern = /^\n[^\S\n]*(?:\|\}|\{\{\s*!\s*\}\}\}|\{\{\s*!\)\s*\}\})$/u;
+/**
+ * 是否是行尾
+ * @param {Token} cell 表格单元格
+ */
+const isRowEnd = ({ type }) => type === 'tr' || type === 'table-syntax';
+exports.isRowEnd = isRowEnd;
+/** @extends {Array<TableCoords[]>} */
+class Layout extends Array {
+    /* NOT FOR BROWSER */
+    /** 打印表格布局 */
+    print() {
+        const hBorders = (0, debug_1.emptyArray)(this.length + 1, i => {
+            const prev = this[i - 1] ?? [], next = this[i] ?? [];
+            return (0, debug_1.emptyArray)(Math.max(prev.length, next.length), j => prev[j] !== next[j]);
+        }), vBorders = this.map(cur => (0, debug_1.emptyArray)(cur.length + 1, j => cur[j - 1] !== cur[j]));
+        let out = '';
+        for (let i = 0; i <= this.length; i++) {
+            const hBorder = hBorders[i].map(Number), vBorderTop = (vBorders[i - 1] ?? []).map(Number), vBorderBottom = (vBorders[i] ?? []).map(Number), 
+            // eslint-disable-next-line no-sparse-arrays
+            border = [' ', , , '┌', , '┐', '─', '┬', , '│', '└', '├', '┘', '┤', '┴', '┼'];
+            for (let j = 0; j <= hBorder.length; j++) {
+                const bit = (vBorderTop[j] << 3) + (vBorderBottom[j] << 0)
+                    + (hBorder[j - 1] << 2) + (hBorder[j] << 1);
+                out += border[bit] + (hBorder[j] ? '─' : ' ');
+            }
+            out += '\n';
+        }
+        console.log(out.slice(0, -1));
+    }
+}
+exports.Layout = Layout;
+/**
+ * 表格
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken, ...TrToken, ?SyntaxToken]}`
+ */
+class TableToken extends trBase_1.TrBaseToken {
+    /* NOT FOR BROWSER END */
+    get type() {
+        return 'table';
+    }
+    /** 表格是否闭合 */
+    get closed() {
+        return this.lastChild.type === 'table-syntax';
+    }
+    /* NOT FOR BROWSER */
+    set closed(closed) {
+        if (closed && !this.closed) {
+            this.close(this.closest('parameter-value') ? '\n{{!}}}' : '\n|}');
+        }
+    }
+    /* NOT FOR BROWSER END */
+    /**
+     * @param syntax 表格语法
+     * @param attr 表格属性
+     */
+    constructor(syntax, attr, config, accum) {
+        super(/^(?:\{\||\{\{\{\s*!\s*\}\}|\{\{\s*\(!\s*\}\})$/u, syntax, 'table', attr, config, accum, {
+            Token: 2, SyntaxToken: [0, -1], AttributesToken: 1, TdToken: '2:', TrToken: '2:',
+        });
+    }
+    /** @private */
+    lint(start = this.getAbsoluteIndex(), re) {
+        const errors = super.lint(start, re), rect = new rect_1.BoundingRect(this, start);
+        if (!this.closed) {
+            errors.push((0, lint_1.generateForChild)(this.firstChild, rect, 'unclosed-table', index_1.default.msg('unclosed $1', 'table')));
+        }
+        const layout = this.getLayout(), { length } = layout;
+        if (length > 1) {
+            let low = 1, high = Infinity, j = 0;
+            for (; j < length; j++) {
+                const row = layout[j], max = row.length;
+                if (max < low) {
+                    break;
+                }
+                else if (max < high) {
+                    high = max;
+                }
+                const min = row.indexOf(row[max - 1]) + 1;
+                if (min > high) {
+                    break;
+                }
+                else if (min > low) {
+                    low = min;
+                }
+            }
+            if (j < length) {
+                const e = (0, lint_1.generateForChild)(this.getNthRow(j), rect, 'table-layout', 'inconsistent table layout', 'warning');
+                e.startIndex++;
+                e.startLine++;
+                e.startCol = 0;
+                errors.push(e);
+            }
+        }
+        return errors;
+    }
+    /**
+     * 闭合表格语法
+     * @param syntax 表格结尾语法
+     * @param halfParsed
+     */
+    close(syntax = '\n|}', halfParsed) {
+        const config = this.getAttribute('config'), accum = this.getAttribute('accum'), inner = halfParsed ? [syntax] : index_1.default.parse(syntax, this.getAttribute('include'), 2, config).childNodes;
+        if (this.lastChild.type !== 'table-syntax') {
+            debug_1.Shadow.run(() => {
+                const token = new syntax_1.SyntaxToken(undefined, closingPattern, 'table-syntax', config, accum, {
+                    'Stage-1': ':', '!ExtToken': '', TranscludeToken: ':',
+                });
+                super.insertAt(token);
+                if (!halfParsed) {
+                    token.afterBuild();
+                }
+            });
+        }
+        this.lastChild.replaceChildren(...inner);
+    }
+    /**
+     * 获取表格布局
+     * @param stop 中止条件
+     * @param stop.row 中止行
+     * @param stop.column 中止列
+     * @param stop.x 中止行
+     * @param stop.y 中止列
+     */
+    getLayout(stop) {
+        const rows = this.getAllRows(), { length } = rows, layout = new Layout(...(0, debug_1.emptyArray)(length, () => []));
+        for (const [i, rowLayout] of layout.entries()) {
+            /* NOT FOR BROWSER */
+            if (i > (stop?.row ?? stop?.y ?? NaN)) {
+                break;
+            }
+            /* NOT FOR BROWSER END */
+            let j = 0, k = 0, last;
+            for (const cell of rows[i].childNodes.slice(2)) {
+                if (cell.type === 'td') {
+                    if (cell.isIndependent()) {
+                        last = cell.subtype !== 'caption';
+                    }
+                    if (last) {
+                        const coords = { row: i, column: j }, { rowspan, colspan } = cell;
+                        j++;
+                        while (rowLayout[k]) {
+                            k++;
+                        }
+                        /* NOT FOR BROWSER */
+                        if (i === stop?.row && j > stop.column) {
+                            rowLayout[k] = coords;
+                            return layout;
+                        }
+                        /* NOT FOR BROWSER END */
+                        for (let y = i; y < Math.min(i + rowspan, length); y++) {
+                            for (let x = k; x < k + colspan; x++) {
+                                layout[y][x] = coords;
+                            }
+                        }
+                        k += colspan;
+                        /* NOT FOR BROWSER */
+                        if (i === stop?.y && k > (stop.x ?? NaN)) {
+                            return layout;
+                        }
+                    }
+                }
+                else if ((0, exports.isRowEnd)(cell)) {
+                    break;
+                }
+            }
+        }
+        return layout;
+    }
+    /** 获取所有行 */
+    getAllRows() {
+        return [
+            ...super.getRowCount() ? [this] : [],
+            ...this.childNodes.slice(1)
+                .filter((child) => child.type === 'tr' && child.getRowCount() > 0),
+        ];
+    }
+    /**
+     * 获取指定坐标的单元格
+     * @param coords 表格坐标
+     */
+    getNthCell(coords) {
+        let rawCoords = coords;
+        if (coords.row === undefined) {
+            rawCoords = this.toRawCoords(coords);
+        }
+        return rawCoords && this.getNthRow(rawCoords.row, false, false)?.getNthCol(rawCoords.column);
+    }
+    getNthRow(n, force, insert) {
+        const isRow = super.getRowCount();
+        /* NOT FOR BROWSER */
+        const nRows = this.getRowCount();
+        n += n < 0 ? nRows : 0;
+        /* NOT FOR BROWSER END */
+        if (n === 0
+            && (isRow
+                || force && nRows === 0)) {
+            return this;
+            /* NOT FOR BROWSER */
+        }
+        else if (n < 0 || n > nRows || n === nRows && !insert) {
+            throw new RangeError(`The table does not have row ${n}!`);
+            /* NOT FOR BROWSER END */
+        }
+        else if (isRow) {
+            n--;
+        }
+        for (const child of this.childNodes.slice(2)) {
+            if (child.type === 'tr' && child.getRowCount()) {
+                n--;
+                if (n < 0) {
+                    return child;
+                }
+                /* NOT FOR BROWSER */
+            }
+            else if (child.type === 'table-syntax') {
+                return child;
+                /* NOT FOR BROWSER END */
+            }
+        }
+        return undefined;
+    }
+    /** @override */
+    json() {
+        const json = super.json();
+        json['closed'] = this.closed;
+        return json;
+    }
+    /* NOT FOR BROWSER */
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     * @throws `SyntaxError` 表格的闭合部分非法
+     */
+    insertAt(token, i = this.length) {
+        i += i < 0 ? this.length : 0;
+        const previous = this.childNodes[i - 1];
+        if (typeof token !== 'string' && token.type === 'td' && previous?.type === 'tr') {
+            index_1.default.warn('The table cell is inserted into the current row instead.');
+            return previous.insertAt(token);
+        }
+        else if (i > 0 && token instanceof syntax_1.SyntaxToken && token.pattern !== closingPattern) {
+            throw new SyntaxError(`The closing part of the table is invalid: ${(0, string_1.noWrap)(token.toString())}`);
+        }
+        return super.insertAt(token, i);
+    }
+    getRowCount() {
+        return super.getRowCount() + this.childNodes.filter(child => child.type === 'tr' && child.getRowCount()).length;
+    }
+    /** 获取下一行 */
+    getNextRow() {
+        return this.getNthRow(super.getRowCount() ? 1 : 0, false, false);
+    }
+    /** 打印表格布局 */
+    printLayout() {
+        require('../../addon/table');
+        this.printLayout();
+    }
+    /**
+     * 转换为渲染后的表格坐标
+     * @param {TableCoords} coord wikitext中的表格坐标
+     */
+    toRenderedCoords(coord) {
+        require('../../addon/table');
+        return this.toRenderedCoords(coord);
+    }
+    /**
+     * 转换为wikitext中的表格坐标
+     * @param {TableRenderedCoords} coord 渲染后的表格坐标
+     */
+    toRawCoords(coord) {
+        require('../../addon/table');
+        return this.toRawCoords(coord);
+    }
+    /**
+     * 获取完整行
+     * @param y 行号
+     */
+    getFullRow(y) {
+        require('../../addon/table');
+        return this.getFullRow(y);
+    }
+    /**
+     * 获取完整列
+     * @param x 列号
+     */
+    getFullCol(x) {
+        require('../../addon/table');
+        return this.getFullCol(x);
+    }
+    /**
+     * 设置行格式
+     * @param y 行号
+     * @param attr 表格属性
+     * @param multiRow 是否对所有单元格设置，或是仅对行首单元格设置
+     */
+    formatTableRow(y, attr, multiRow) {
+        require('../../addon/table');
+        this.formatTableRow(y, attr, multiRow);
+    }
+    /**
+     * 设置列格式
+     * @param x 列号
+     * @param attr 表格属性
+     * @param multiCol 是否对所有单元格设置，或是仅对行首单元格设置
+     */
+    formatTableCol(x, attr, multiCol) {
+        require('../../addon/table');
+        this.formatTableCol(x, attr, multiCol);
+    }
+    /**
+     * 填补表格行
+     * @param y 行号
+     * @param inner 填充内容
+     * @param subtype 单元格类型
+     * @param attr 表格属性
+     */
+    fillTableRow(y, inner, subtype, attr) {
+        require('../../addon/table');
+        this.fillTableRow(y, inner, subtype, attr);
+    }
+    /**
+     * 填补表格
+     * @param inner 填充内容
+     * @param subtype 单元格类型
+     * @param attr 表格属性
+     */
+    fillTable(inner, subtype, attr) {
+        require('../../addon/table');
+        this.fillTable(inner, subtype, attr);
+    }
+    insertTableCell(inner, coords, subtype, attr) {
+        require('../../addon/table');
+        return this.insertTableCell(inner, coords, subtype, attr);
+    }
+    /** @private */
+    prependTableRow() {
+        require('../../addon/table');
+        return this.prependTableRow();
+    }
+    /**
+     * 插入表格行
+     * @param y 行号
+     * @param attr 表格行属性
+     * @param inner 内部wikitext
+     * @param subtype 单元格类型
+     * @param innerAttr 单元格属性
+     */
+    insertTableRow(y, attr, inner, subtype, innerAttr) {
+        require('../../addon/table');
+        return this.insertTableRow(y, attr, inner, subtype, innerAttr);
+    }
+    /**
+     * 插入表格列
+     * @param x 列号
+     * @param inner 内部wikitext
+     * @param subtype 单元格类型
+     * @param attr 单元格属性
+     * @throws `RangeError` 列号过大
+     */
+    insertTableCol(x, inner, subtype, attr) {
+        require('../../addon/table');
+        this.insertTableCol(x, inner, subtype, attr);
+    }
+    /**
+     * 移除表格行
+     * @param y 行号
+     */
+    removeTableRow(y) {
+        require('../../addon/table');
+        return this.removeTableRow(y);
+    }
+    /**
+     * 移除表格列
+     * @param x 列号
+     */
+    removeTableCol(x) {
+        require('../../addon/table');
+        this.removeTableCol(x);
+    }
+    /**
+     * 合并单元格
+     * @param xlim 列范围
+     * @param ylim 行范围
+     * @throws `RangeError` 待合并区域与外侧区域有重叠
+     */
+    mergeCells(xlim, ylim) {
+        require('../../addon/table');
+        return this.mergeCells(xlim, ylim);
+    }
+    /** @private */
+    split(coords, dirs) {
+        require('../../addon/table');
+        this.split(coords, dirs);
+    }
+    /**
+     * 分裂成多行
+     * @param coords 单元格坐标
+     */
+    splitIntoRows(coords) {
+        require('../../addon/table');
+        this.splitIntoRows(coords);
+    }
+    /**
+     * 分裂成多列
+     * @param coords 单元格坐标
+     */
+    splitIntoCols(coords) {
+        require('../../addon/table');
+        this.splitIntoCols(coords);
+    }
+    /**
+     * 分裂成单元格
+     * @param coords 单元格坐标
+     */
+    splitIntoCells(coords) {
+        require('../../addon/table');
+        this.splitIntoCells(coords);
+    }
+    /**
+     * 复制一行并插入该行之前
+     * @param row 行号
+     */
+    replicateTableRow(row) {
+        require('../../addon/table');
+        return this.replicateTableRow(row);
+    }
+    /**
+     * 复制一列并插入该列之前
+     * @param x 列号
+     */
+    replicateTableCol(x) {
+        require('../../addon/table');
+        return this.replicateTableCol(x);
+    }
+    /** @private */
+    moveCol(x, reference, after) {
+        require('../../addon/table');
+        this.moveCol(x, reference, after);
+    }
+    /**
+     * 移动表格行
+     * @param y 行号
+     * @param before 新位置
+     * @throws `RangeError` 无法移动
+     */
+    moveTableRowBefore(y, before) {
+        require('../../addon/table');
+        return this.moveTableRowBefore(y, before);
+    }
+    /**
+     * 移动表格行
+     * @param y 行号
+     * @param after 新位置
+     * @throws `RangeError` 无法移动
+     */
+    moveTableRowAfter(y, after) {
+        require('../../addon/table');
+        return this.moveTableRowAfter(y, after);
+    }
+    /**
+     * 移动表格列
+     * @param x 列号
+     * @param before 新位置
+     */
+    moveTableColBefore(x, before) {
+        require('../../addon/table');
+        this.moveTableColBefore(x, before);
+    }
+    /**
+     * 移动表格列
+     * @param x 列号
+     * @param after 新位置
+     */
+    moveTableColAfter(x, after) {
+        require('../../addon/table');
+        this.moveTableColAfter(x, after);
+    }
+    /** @private */
+    toHtmlInternal(nowrap) {
+        /**
+         * 过滤需要移出表格的节点
+         * @param token 表格或表格行
+         */
+        const filter = (token) => token.childNodes.filter((0, debug_1.isToken)('table-inter'));
+        const { childNodes } = this, tr = childNodes.filter((0, debug_1.isToken)('tr')), inter = [this, ...tr].flatMap(filter).map(token => token.toHtmlInternal(true).trim()).join(' ');
+        return `${inter}<table${childNodes[1].toHtmlInternal()}>${nowrap ? ' ' : '\n'}<tbody>${super.toHtmlInternal(nowrap)}${(0, html_1.html)(tr, '', nowrap)}</tbody></table>`;
+    }
+}
+exports.TableToken = TableToken;
+constants_1.classes['TableToken'] = __filename;

package/dist/src/table/td.d.ts

@@ -0,0 +1,72 @@
+import Parser from '../../index';
+import { Token } from '../index';
+import { TableBaseToken } from './base';
+import type { LintError, AST } from '../../base';
+import type { SyntaxToken, AttributesToken, TrToken, TableToken } from '../../internal';
+export type TdSubtypes = 'td' | 'th' | 'caption';
+export interface TdSpanAttrs {
+    rowspan?: number;
+    colspan?: number;
+}
+declare type TdAttrGetter<T extends string> = T extends keyof TdSpanAttrs ? number : string | true | undefined;
+declare type TdAttrSetter<T extends string> = T extends keyof TdSpanAttrs ? number : string | boolean;
+export type TdAttrs = Record<string, string | true> & TdSpanAttrs;
+/**
+ * `<td>`、`<th>`和`<caption>`
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, Token]}`
+ */
+export declare abstract class TdToken extends TableBaseToken {
+    #private;
+    readonly childNodes: readonly [SyntaxToken, AttributesToken, Token];
+    abstract get parentNode(): TrToken | TableToken | undefined;
+    abstract get nextSibling(): this | TrToken | SyntaxToken | undefined;
+    abstract get previousSibling(): Token | undefined;
+    abstract get children(): [SyntaxToken, AttributesToken, Token];
+    abstract get parentElement(): TrToken | TableToken | undefined;
+    abstract get nextElementSibling(): this | TrToken | SyntaxToken | undefined;
+    get type(): 'td';
+    /** rowspan */
+    get rowspan(): number;
+    /** colspan */
+    get colspan(): number;
+    /** 单元格类型 */
+    get subtype(): TdSubtypes;
+    set subtype(subtype: TdSubtypes);
+    set rowspan(rowspan: number);
+    set colspan(colspan: number);
+    /** 内部wikitext */
+    get innerText(): string;
+    set innerText(text: string);
+    /**
+     * @param syntax 单元格语法
+     * @param inner 内部wikitext
+     */
+    constructor(syntax: string, inner?: string, config?: Parser.Config, accum?: Token[]);
+    /** 是否位于行首 */
+    isIndependent(): boolean;
+    getAttr<T extends string>(key: T): TdAttrGetter<T>;
+    /** @override */
+    json(): AST;
+    cloneNode(): this;
+    /** 改为独占一行 */
+    independence(): void;
+    getAttrs(): TdAttrs;
+    /**
+     * @override
+     * @param key 属性键
+     * @param value 属性值
+     * @param prop 属性对象
+     */
+    setAttr<T extends string>(key: T, value: TdAttrSetter<T>): void;
+    setAttr(prop: Record<string, string | number | boolean>): void;
+}
+/**
+ * 创建新的单元格
+ * @param inner 内部wikitext
+ * @param subtype 单元格类型
+ * @param attr 单元格属性
+ * @param include 是否嵌入
+ * @param config
+ */
+export declare const createTd: (inner: string | Token, subtype?: TdSubtypes, attr?: TdAttrs, include?: boolean, config?: Parser.Config) => TdToken;
+export {};