wikiparser-node 1.2.0-b → 1.2.0

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

@@ -0,0 +1,103 @@
+import * as Parser from '../../index';
+import { Token } from '../index';
+import { TableBaseToken } from './base';
+import type { LintError } 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;
+declare const TdToken_base: ((abstract new (...args: any[]) => {
+    removeAt(): never;
+    insertAt(token: string, i?: number | undefined): Parser.AstText;
+    insertAt<T extends Parser.AstNodes>(token: T, i?: number | undefined): T;
+    readonly length: number;
+    toString(omit?: Set<string> | undefined, separator?: string | undefined): string;
+    text(separator?: string | undefined): string;
+    afterBuild(): void;
+    getAttribute<T_1 extends string>(key: T_1): TokenAttributeGetter<T_1>;
+    setAttribute<T_2 extends string>(key: T_2, value: TokenAttributeSetter<T_2>): void;
+    addEventListener(events: string | string[], listener: AstListener): void;
+    replaceChildren(...elements: (string | Parser.AstNodes)[]): void;
+}) & {
+    readonly fixed: true;
+}) & typeof TableBaseToken;
+/**
+ * `<td>`、`<th>`和`<caption>`
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, Token]}`
+ */
+export declare class TdToken extends TdToken_base {
+    #private;
+    readonly type = "td";
+    readonly childNodes: [SyntaxToken, AttributesToken, Token];
+    abstract get children(): [SyntaxToken, AttributesToken, Token];
+    abstract get parentNode(): TrToken | TableToken | undefined;
+    abstract get parentElement(): TrToken | TableToken | undefined;
+    abstract get nextSibling(): this | TrToken | SyntaxToken | undefined;
+    abstract get nextElementSibling(): this | TrToken | SyntaxToken | undefined;
+    abstract get previousSibling(): Token | undefined;
+    /** 单元格类型 */
+    get subtype(): TdSubtypes;
+    set subtype(subtype: TdSubtypes);
+    /** rowspan */
+    get rowspan(): number;
+    set rowspan(rowspan: number);
+    /** colspan */
+    get colspan(): 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[]);
+    /** @override */
+    text(): string;
+    /** @override */
+    lint(start?: number): LintError[];
+    /** @override */
+    print(): string;
+    /** 是否位于行首 */
+    isIndependent(): boolean;
+    /** @override */
+    cloneNode(): this;
+    /**
+     * @override
+     * @param syntax 表格语法
+     * @param esc 是否需要转义
+     */
+    setSyntax(syntax: string, esc?: boolean): void;
+    /** 改为独占一行 */
+    independence(): void;
+    /**
+     * @override
+     * @param key 属性键
+     */
+    getAttr<T extends string>(key: T): TdAttrGetter<T>;
+    /** @override */
+    getAttrs(): TdAttrs;
+    /**
+     * @override
+     * @param key 属性键
+     * @param value 属性值
+     */
+    setAttr<T extends string>(key: T, value: TdAttrSetter<T>): void;
+    /** @override */
+    escape(): 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 {};

package/dist/src/table/td.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTd = exports.TdToken = void 0;
+const lint_1 = require("../../util/lint");
+const debug_1 = require("../../util/debug");
+const constants_1 = require("../../util/constants");
+const fixed_1 = require("../../mixin/fixed");
+const Parser = require("../../index");
+const index_1 = require("../index");
+const base_1 = require("./base");
+/**
+ * `<td>`、`<th>`和`<caption>`
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, Token]}`
+ */
+// @ts-expect-error not implementing all abstract methods
+class TdToken extends (0, fixed_1.fixed)(base_1.TableBaseToken) {
+    type = 'td';
+    #innerSyntax = '';
+    /** 单元格类型 */
+    get subtype() {
+        return this.#getSyntax().subtype;
+    }
+    /* NOT FOR BROWSER */
+    set subtype(subtype) {
+        this.setSyntax(subtype);
+    }
+    /** rowspan */
+    get rowspan() {
+        return this.getAttr('rowspan');
+    }
+    set rowspan(rowspan) {
+        this.setAttr('rowspan', rowspan);
+    }
+    /** colspan */
+    get colspan() {
+        return this.getAttr('colspan');
+    }
+    set colspan(colspan) {
+        this.setAttr('colspan', colspan);
+    }
+    /** 内部wikitext */
+    get innerText() {
+        return this.lastChild.text();
+    }
+    set innerText(text) {
+        this.lastChild.replaceChildren(...Parser.parse(text, true, undefined, this.getAttribute('config')).childNodes);
+    }
+    /* NOT FOR BROWSER END */
+    /**
+     * @param syntax 单元格语法
+     * @param inner 内部wikitext
+     */
+    constructor(syntax, inner, config = Parser.getConfig(), accum = []) {
+        let innerSyntax = /\||\0\d+!\x7F/u.exec(inner ?? ''), attr = innerSyntax ? inner.slice(0, innerSyntax.index) : '';
+        if (/\[\[|-\{/u.test(attr)) {
+            innerSyntax = null;
+            attr = '';
+        }
+        super(/^(?:\n[^\S\n]*(?:[|!]|\|\+|\{\{\s*!\s*\}\}\+?)|(?:\||\{\{\s*!\s*\}\}){2}|!!|\{\{\s*!!\s*\}\})$/u, syntax, attr, config, accum, { SyntaxToken: 0, AttributesToken: 1, Token: 2 });
+        if (innerSyntax) {
+            [this.#innerSyntax] = innerSyntax;
+        }
+        const innerToken = new index_1.Token(inner?.slice((innerSyntax?.index ?? NaN) + this.#innerSyntax.length), config, accum);
+        innerToken.type = 'td-inner';
+        innerToken.setAttribute('stage', 4);
+        this.insertAt(innerToken);
+    }
+    /** 表格语法信息 */
+    #getSyntax() {
+        const syntax = this.firstChild.text(), esc = syntax.includes('{{'), char = syntax.at(-1);
+        let subtype = 'td';
+        if (char === '!') {
+            subtype = 'th';
+        }
+        else if (char === '+') {
+            subtype = 'caption';
+        }
+        if (this.isIndependent()) {
+            return { subtype, escape: esc, correction: false };
+        }
+        const { previousSibling } = this;
+        if (!(previousSibling instanceof TdToken)) {
+            return { subtype, escape: esc, correction: true };
+        }
+        const result = previousSibling.#getSyntax();
+        result.escape ||= esc;
+        result.correction = previousSibling.lastChild
+            .toString(new Set(['comment', 'ext', 'include', 'noinclude', 'arg', 'template', 'magic-word']))
+            .includes('\n');
+        if (subtype === 'th' && result.subtype !== 'th') {
+            result.subtype = 'th';
+            result.correction = true;
+        }
+        return result;
+    }
+    /** @private */
+    afterBuild() {
+        if (this.#innerSyntax.includes('\0')) {
+            this.#innerSyntax = this.buildFromStr(this.#innerSyntax, 'string');
+        }
+    }
+    /** @private */
+    toString(omit) {
+        this.#correct();
+        const { childNodes: [syntax, attr, inner] } = this;
+        return omit && this.matchesTypes(omit)
+            ? ''
+            : `${syntax.toString(omit)}${attr.toString(omit)}${this.#innerSyntax}${inner.toString(omit)}`;
+    }
+    /** @override */
+    text() {
+        this.#correct();
+        const { childNodes: [syntax, attr, inner] } = this;
+        return `${syntax.text()}${attr.text()}${this.#innerSyntax}${inner.text()}`;
+    }
+    /** @private */
+    getGaps(i) {
+        if (i === 1) {
+            this.#correct();
+            return this.#innerSyntax.length;
+        }
+        return 0;
+    }
+    /** @override */
+    lint(start = this.getAbsoluteIndex()) {
+        const errors = super.lint(start);
+        start += this.getRelativeIndex(this.length - 1);
+        for (const child of this.lastChild.childNodes) {
+            if (child.type === 'text' && child.data.includes('|')) {
+                errors.push((0, lint_1.generateForChild)(child, { start }, 'additional "|" in a table cell', 'warning'));
+            }
+        }
+        return errors;
+    }
+    /** @override */
+    print() {
+        const { childNodes: [syntax, attr, inner] } = this;
+        return `<span class="wpb-td">${syntax.print()}${attr.print()}${this.#innerSyntax}${inner.print()}</span>`;
+    }
+    /* NOT FOR BROWSER */
+    /** 是否位于行首 */
+    isIndependent() {
+        return this.firstChild.text().startsWith('\n');
+    }
+    /** @override */
+    cloneNode() {
+        const token = super.cloneNode();
+        token.setAttribute('innerSyntax', this.#innerSyntax);
+        return token;
+    }
+    /** @private */
+    getAttribute(key) {
+        return key === 'innerSyntax' ? this.#innerSyntax : super.getAttribute(key);
+    }
+    /** @private */
+    setAttribute(key, value) {
+        if (key === 'innerSyntax') {
+            this.#innerSyntax = value ?? '';
+        }
+        else {
+            super.setAttribute(key, value);
+        }
+    }
+    /**
+     * @override
+     * @param syntax 表格语法
+     * @param esc 是否需要转义
+     */
+    setSyntax(syntax, esc = false) {
+        const aliases = { td: '\n|', th: '\n!', caption: '\n|+' };
+        super.setSyntax(aliases[syntax] ?? syntax, esc);
+    }
+    /** 修复\<td\>语法 */
+    #correct() {
+        if (String(this.childNodes[1])) {
+            this.#innerSyntax ||= '|';
+        }
+        const { subtype, escape, correction } = this.#getSyntax();
+        if (correction) {
+            this.setSyntax(subtype, escape);
+        }
+    }
+    /** 改为独占一行 */
+    independence() {
+        if (!this.isIndependent()) {
+            const { subtype, escape } = this.#getSyntax();
+            this.setSyntax(subtype, escape);
+        }
+    }
+    /**
+     * @override
+     * @param key 属性键
+     */
+    getAttr(key) {
+        const value = super.getAttr(key);
+        key = key.toLowerCase().trim();
+        return (key === 'rowspan' || key === 'colspan' ? Number(value) || 1 : value);
+    }
+    /** @override */
+    getAttrs() {
+        const attr = super.getAttrs();
+        if ('rowspan' in attr) {
+            attr.rowspan = Number(attr.rowspan);
+        }
+        if ('colspan' in attr) {
+            attr.colspan = Number(attr.colspan);
+        }
+        return attr;
+    }
+    /**
+     * @override
+     * @param key 属性键
+     * @param value 属性值
+     */
+    setAttr(key, value) {
+        key = key.toLowerCase().trim();
+        let v;
+        if (typeof value === 'number' && (key === 'rowspan' || key === 'colspan')) {
+            v = value === 1 ? false : String(value);
+        }
+        else {
+            v = value;
+        }
+        super.setAttr(key, v);
+        if (!String(this.childNodes[1])) {
+            this.#innerSyntax = '';
+        }
+    }
+    /** @override */
+    escape() {
+        super.escape();
+        if (String(this.childNodes[1])) {
+            this.#innerSyntax ||= '{{!}}';
+        }
+        if (this.#innerSyntax === '|') {
+            this.#innerSyntax = '{{!}}';
+        }
+    }
+}
+exports.TdToken = TdToken;
+/* NOT FOR BROWSER */
+/**
+ * 创建新的单元格
+ * @param inner 内部wikitext
+ * @param subtype 单元格类型
+ * @param attr 单元格属性
+ * @param include 是否嵌入
+ * @param config
+ */
+const createTd = (inner, subtype = 'td', attr = {}, include = false, config = Parser.getConfig()) => {
+    const innerToken = typeof inner === 'string' ? Parser.parse(inner, include, undefined, config) : inner, token = debug_1.Shadow.run(() => new TdToken('\n|', undefined, config));
+    token.setSyntax(subtype);
+    token.lastChild.safeReplaceWith(innerToken);
+    for (const [k, v] of Object.entries(attr)) {
+        token.setAttr(k, v);
+    }
+    return token;
+};
+exports.createTd = createTd;
+/* NOT FOR BROWSER END */
+constants_1.classes['TdToken'] = __filename;

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

@@ -0,0 +1,32 @@
+import * as Parser from '../../index';
+import { TrBaseToken } from './trBase';
+import type { Token, TdToken, TableToken, SyntaxToken, AttributesToken } from '../../internal';
+/**
+ * 表格行，含开头的换行，不含结尾的换行
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken]}`
+ */
+export declare class TrToken extends TrBaseToken {
+    #private;
+    readonly type = "tr";
+    readonly childNodes: [SyntaxToken, AttributesToken, ...TdToken[]];
+    abstract get children(): [SyntaxToken, AttributesToken, ...TdToken[]];
+    abstract get lastChild(): AttributesToken | TdToken;
+    abstract get lastElementChild(): AttributesToken | TdToken;
+    abstract get parentNode(): TableToken | undefined;
+    abstract get parentElement(): TableToken | undefined;
+    abstract get nextSibling(): this | SyntaxToken | undefined;
+    abstract get nextElementSibling(): this | SyntaxToken | undefined;
+    abstract get previousSibling(): Token;
+    abstract get previousElementSibling(): Token;
+    /**
+     * @param syntax 表格语法
+     * @param attr 表格属性
+     */
+    constructor(syntax: string, attr?: string, config?: Parser.Config, accum?: Token[]);
+    /** @override */
+    text(): string;
+    /** 获取下一行 */
+    getNextRow(): TrToken | undefined;
+    /** 获取前一行 */
+    getPreviousRow(): TrToken | undefined;
+}

package/dist/src/table/tr.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrToken = void 0;
+const constants_1 = require("../../util/constants");
+const Parser = require("../../index");
+const trBase_1 = require("./trBase");
+/**
+ * 表格行，含开头的换行，不含结尾的换行
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken]}`
+ */
+// @ts-expect-error not implementing all abstract methods
+class TrToken extends trBase_1.TrBaseToken {
+    type = 'tr';
+    /**
+     * @param syntax 表格语法
+     * @param attr 表格属性
+     */
+    constructor(syntax, attr, config = Parser.getConfig(), accum = []) {
+        super(/^\n[^\S\n]*(?:\|-+|\{\{\s*!\s*\}\}-+|\{\{\s*!-\s*\}\}-*)$/u, syntax, attr, config, accum, {
+            Token: 2, SyntaxToken: 0, AttributesToken: 1, TdToken: '2:',
+        });
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    text() {
+        const str = super.text();
+        return str.trim().includes('\n') ? str : '';
+    }
+    /**
+     * 获取相邻行
+     * @param subset 筛选兄弟节点的方法
+     */
+    #getSiblingRow(subset) {
+        const { parentNode } = this;
+        if (!parentNode) {
+            return undefined;
+        }
+        const { childNodes } = parentNode, index = childNodes.indexOf(this);
+        for (const child of subset(childNodes, index)) {
+            if (child instanceof TrToken && child.getRowCount()) {
+                return child;
+            }
+        }
+        return undefined;
+    }
+    /** 获取下一行 */
+    getNextRow() {
+        return this.#getSiblingRow((childNodes, index) => childNodes.slice(index + 1));
+    }
+    /** 获取前一行 */
+    getPreviousRow() {
+        return this.#getSiblingRow((childNodes, index) => childNodes.slice(0, index).reverse());
+    }
+}
+exports.TrToken = TrToken;
+constants_1.classes['TrToken'] = __filename;

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

@@ -0,0 +1,54 @@
+import { Token } from '..';
+import { TableBaseToken } from './base';
+import { TdToken } from './td';
+import type { LintError } from '../../base';
+import type { AstNodes, SyntaxToken, TrToken } from '../../internal';
+import type { TdAttrs, TdSubtypes } from './td';
+export interface TableCoords {
+    readonly row: number;
+    readonly column: number;
+    readonly x?: undefined;
+    readonly y?: undefined;
+    readonly start?: boolean;
+}
+/** 表格行或表格 */
+export declare abstract class TrBaseToken extends TableBaseToken {
+    #private;
+    type: 'table' | 'tr';
+    /** @override */
+    lint(start?: number): LintError[];
+    /** @override */
+    text(): string;
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i: number): AstNodes;
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt<T extends Token>(token: T, i?: number): T;
+    /** 获取行数 */
+    getRowCount(): number;
+    /** 获取列数 */
+    getColCount(): number;
+    /**
+     * 获取第n列
+     * @param n 列号
+     * @param insert 是否用于判断插入新列的位置
+     * @throws `RangeError` 不存在对应单元格
+     */
+    getNthCol(n: number, insert?: false): TdToken | undefined;
+    /** @ignore */
+    getNthCol(n: number, insert: true): TdToken | TrToken | SyntaxToken | undefined;
+    /**
+     * 插入新的单元格
+     * @param inner 单元格内部wikitext
+     * @param {TableCoords} coord 单元格坐标
+     * @param subtype 单元格类型
+     * @param attr 单元格属性
+     */
+    insertTableCell(inner: string | Token, { column }: TableCoords, subtype?: TdSubtypes, attr?: TdAttrs): TdToken;
+}

package/dist/src/table/trBase.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrBaseToken = void 0;
+const lint_1 = require("../../util/lint");
+const debug_1 = require("../../util/debug");
+const constants_1 = require("../../util/constants");
+const __1 = require("..");
+const base_1 = require("./base");
+const td_1 = require("./td");
+/** 表格行或表格 */
+class TrBaseToken extends base_1.TableBaseToken {
+    /** @override */
+    lint(start = this.getAbsoluteIndex()) {
+        const errors = super.lint(start), inter = this.childNodes.find(({ type }) => type === 'table-inter');
+        if (!inter) {
+            return errors;
+        }
+        const first = inter.childNodes.find(child => child.text().trim()), tdPattern = /^\s*(?:!|\{\{\s*![!-]?\s*\}\})/u, 
+        /** @ignore */
+        isArg = (token) => token.type === 'arg', 
+        /** @ignore */
+        isTransclude = (token) => token.type === 'magic-word';
+        if (!first || tdPattern.test(String(first))
+            || isArg(first) && tdPattern.test(first.default || '')) {
+            return errors;
+        }
+        else if (isTransclude(first)) {
+            try {
+                if (first.getPossibleValues().every(token => tdPattern.test(token.text()))) {
+                    return errors;
+                }
+            }
+            catch { }
+        }
+        const error = (0, lint_1.generateForChild)(inter, { start }, 'content to be moved out from the table');
+        errors.push({
+            ...error,
+            startIndex: error.startIndex + 1,
+            startLine: error.startLine + 1,
+            startCol: 0,
+            excerpt: error.excerpt.slice(1),
+        });
+        return errors;
+    }
+    /* NOT FOR BROWSER */
+    /** 修复简单的表格语法错误 */
+    #correct() {
+        const { childNodes: [, , child] } = this;
+        if (child?.constructor === __1.Token) {
+            const { firstChild } = child;
+            if (firstChild?.type !== 'text') {
+                child.prepend('\n');
+            }
+            else if (!firstChild.data.startsWith('\n')) {
+                firstChild.insertData(0, '\n');
+            }
+        }
+    }
+    /** @override */
+    text() {
+        this.#correct();
+        return super.text();
+    }
+    /** @private */
+    toString(omit) {
+        this.#correct();
+        return super.toString(omit);
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        const child = this.childNodes.at(i);
+        if (child instanceof td_1.TdToken && child.isIndependent()) {
+            const { nextSibling } = child;
+            if (nextSibling?.type === 'td') {
+                nextSibling.independence();
+            }
+        }
+        return super.removeAt(i);
+    }
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt(token, i = this.length) {
+        if (!debug_1.Shadow.running && token.type !== 'td') {
+            if (this.type === 'tr') {
+                this.typeError('insertAt', 'TdToken');
+            }
+            else if (token.type !== 'tr') {
+                this.typeError('insertAt', 'TrToken', 'TdToken');
+            }
+        }
+        const child = this.childNodes.at(i);
+        if (token instanceof td_1.TdToken && token.isIndependent() && child instanceof td_1.TdToken) {
+            child.independence();
+        }
+        return super.insertAt(token, i);
+    }
+    /** 获取行数 */
+    getRowCount() {
+        return Number(this.childNodes.some(child => child instanceof td_1.TdToken && child.isIndependent() && !child.firstChild.text().endsWith('+')));
+    }
+    /** 获取列数 */
+    getColCount() {
+        let count = 0, last = 0;
+        for (const child of this.childNodes) {
+            if (child instanceof td_1.TdToken) {
+                last = child.isIndependent() ? Number(child.subtype !== 'caption') : last;
+                count += last;
+            }
+        }
+        return count;
+    }
+    /** @ignore */
+    getNthCol(n, insert = false) {
+        const nCols = this.getColCount();
+        n += n < 0 ? nCols : 0;
+        if (n < 0 || n > nCols || n === nCols && !insert) {
+            throw new RangeError(`不存在第 ${n} 个单元格！`);
+        }
+        let last = 0;
+        /** @ignore */
+        const isTr = (token) => token.type === 'tr', 
+        /** @ignore */
+        isSyntax = (token) => token.type === 'table-syntax';
+        for (const child of this.childNodes.slice(2)) {
+            if (child instanceof td_1.TdToken) {
+                if (child.isIndependent()) {
+                    last = Number(child.subtype !== 'caption');
+                }
+                n -= last;
+                if (n < 0) {
+                    return child;
+                }
+            }
+            else if (isTr(child) || isSyntax(child)) {
+                return child;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 插入新的单元格
+     * @param inner 单元格内部wikitext
+     * @param {TableCoords} coord 单元格坐标
+     * @param subtype 单元格类型
+     * @param attr 单元格属性
+     */
+    insertTableCell(inner, { column }, subtype = 'td', attr = {}) {
+        const token = (0, td_1.createTd)(inner, subtype, attr, this.getAttribute('include'), this.getAttribute('config'));
+        return this.insertBefore(token, this.getNthCol(column, true));
+    }
+}
+exports.TrBaseToken = TrBaseToken;
+constants_1.classes['TrBaseToken'] = __filename;