wikiparser-node 0.3.1 → 0.5.0

package/src/table/td.js

@@ -2,10 +2,13 @@
 
 const fixedToken = require('../../mixin/fixedToken'),
 	{externalUse, typeError} = require('../../util/debug'),
-	/** @type {Parser} */ Parser = require('../..'),
+	Parser = require('../..'),
 	Token = require('..'),
 	TrToken = require('./tr');
 
+const aliases = {td: '\n|', th: '\n!', caption: '\n|+'},
+	openingPattern = /^(?:\n[\S\n]*(?:[|!]|\|\+|\{\{\s*!\s*\}\}\+?)|(?:\||\{\{\s*!\s*\}\}){2}|!!|\{\{\s*!!\s*\}\})$/u;
+
 /**
  * `<td>`、`<th>`和`<caption>`
  * @classdesc `{childNodes: [SyntaxToken, AttributeToken, Token]}`
@@ -14,54 +17,73 @@ class TdToken extends fixedToken(TrToken) {
 	type = 'td';
 	#innerSyntax = '';
 
-	/** @complexity `n` */
+	/**
+	 * 单元格类型
+	 * @complexity `n`
+	 */
 	get subtype() {
 		return this.getSyntax().subtype;
 	}
+
 	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();
+	}
+
+	/** 是否位于行首 */
 	isIndependent() {
-		return this.firstElementChild.text().startsWith('\n');
+		return this.firstChild.text()[0] === '\n';
 	}
 
 	/**
+	 * 获取单元格语法信息
 	 * @returns {{subtype: 'td'|'th'|'caption', escape: boolean, correction: boolean}}
 	 * @complexity `n`
 	 */
 	getSyntax() {
-		const syntax = this.firstElementChild.text(),
-			esc = syntax.includes('{{');
+		const syntax = this.firstChild.text(),
+			esc = syntax.includes('{{'),
+			char = syntax.at(-1);
 		let subtype = 'td';
-		if (syntax.endsWith('!')) {
+		if (char === '!') {
 			subtype = 'th';
-		} else if (syntax.endsWith('+')) {
+		} else if (char === '+') {
 			subtype = 'caption';
 		}
 		if (this.isIndependent()) {
 			return {subtype, escape: esc, correction: false};
 		}
-		const {previousElementSibling} = this;
-		if (previousElementSibling?.type !== 'td') {
+		const {previousSibling} = this;
+		if (previousSibling?.type !== 'td') {
 			return {subtype, escape: esc, correction: true};
 		}
-		const result = previousElementSibling.getSyntax();
+		const result = previousSibling.getSyntax();
 		result.escape ||= esc;
-		result.correction = previousElementSibling.lastElementChild.offsetHeight > 1;
+		result.correction = previousSibling.lastChild
+			.toString('comment, ext, include, noinclude, arg, template, magic-word, html')
+			.includes('\n');
 		if (subtype === 'th' && result.subtype !== 'th') {
 			result.subtype = 'th';
 			result.correction = true;
@@ -69,26 +91,23 @@ class TdToken extends fixedToken(TrToken) {
 		return result;
 	}
 
-	static openingPattern
-		= /^(?:\n[\S\n]*(?:[|!]|\|\+|\{\{\s*!\s*\}\}\+?)|(?:\||\{\{\s*!\s*\}\}){2}|!!|\{\{\s*!!\s*\}\})$/;
-
 	getRowCount = undefined;
 	getNthCol = undefined;
 	insertTableCell = undefined;
 
 	/**
-	 * @param {string} syntax
-	 * @param {string} inner
+	 * @param {string} syntax 单元格语法
+	 * @param {string} inner 内部wikitext
 	 * @param {accum} accum
 	 */
 	constructor(syntax, inner, config = Parser.getConfig(), accum = []) {
-		let innerSyntax = /\||\0\d+!\x7f/.exec(inner),
+		let innerSyntax = inner?.match(/\||\0\d+!\x7F/u),
 			attr = innerSyntax ? inner.slice(0, innerSyntax.index) : '';
-		if (/\[\[|-\{/.test(attr)) {
+		if (/\[\[|-\{/u.test(attr)) {
 			innerSyntax = null;
 			attr = '';
 		}
-		super(syntax, attr, config, accum, TdToken.openingPattern);
+		super(syntax, attr, config, accum, openingPattern);
 		if (innerSyntax) {
 			[this.#innerSyntax] = innerSyntax;
 		}
@@ -96,9 +115,11 @@ class TdToken extends fixedToken(TrToken) {
 		const innerToken = new Token(inner?.slice(innerSyntax?.index + this.#innerSyntax.length), config, true, accum);
 		innerToken.type = 'td-inner';
 		this.setAttribute('acceptable', {SyntaxToken: 0, AttributeToken: 1, Token: 2})
-			.seal(['getRowCount', 'getNthCol', 'insertTableCell']).appendChild(innerToken.setAttribute('stage', 4));
+			.seal(['getRowCount', 'getNthCol', 'insertTableCell'], true)
+			.appendChild(innerToken.setAttribute('stage', 4));
 	}
 
+	/** @override */
 	cloneNode() {
 		const /** @type {TdToken} */ token = super.cloneNode();
 		token.setAttribute('innerSyntax', this.#innerSyntax);
@@ -106,21 +127,24 @@ class TdToken extends fixedToken(TrToken) {
 	}
 
 	/**
-	 * @param {string|Token} inner
-	 * @param {'td'|'th'|'caption'} subtype
-	 * @param {Record<string, string>} attr
+	 * 创建新的单元格
+	 * @param {string|Token} inner 内部wikitext
+	 * @param {'td'|'th'|'caption'} subtype 单元格类型
+	 * @param {Record<string, string>} attr 单元格属性
+	 * @param {boolean} include 是否嵌入
+	 * @throws `RangeError` 非法的单元格类型
 	 */
 	static create(inner, subtype = 'td', attr = {}, include = false, config = Parser.getConfig()) {
 		if (typeof inner !== 'string' && (!(inner instanceof Token) || !inner.isPlain()) || typeof attr !== 'object') {
 			typeError(this, 'create', 'String', 'Token', 'Object');
-		} else if (!['td', 'th', 'caption'].includes(subtype)) {
+		} else if (subtype !== 'td' && subtype !== 'th' && subtype !== 'caption') {
 			throw new RangeError('单元格的子类型只能为 "td"、"th" 或 "caption"！');
 		} else if (typeof inner === 'string') {
 			inner = Parser.parse(inner, include, undefined, config);
 		}
 		const token = Parser.run(() => new TdToken('\n|', undefined, config));
 		token.setSyntax(subtype);
-		token.lastElementChild.safeReplaceWith(inner);
+		token.lastChild.safeReplaceWith(inner);
 		for (const [k, v] of Object.entries(attr)) {
 			token.setAttr(k, v);
 		}
@@ -128,22 +152,22 @@ class TdToken extends fixedToken(TrToken) {
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {TokenAttribute<T>}
 	 */
 	getAttribute(key) {
-		if (key === 'innerSyntax') {
-			return this.#innerSyntax;
-		}
-		return super.getAttribute(key);
+		return key === 'innerSyntax' ? this.#innerSyntax : super.getAttribute(key);
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
-	 * @param {TokenAttribute<T>} value
-	 * @return {this}
+	 * @param {T} key 属性键
+	 * @param {TokenAttribute<T>} value 属性值
+	 * @returns {this}
+	 * @throws `RangeError` 仅用于代码调试
 	 */
 	setAttribute(key, value) {
 		if (key !== 'innerSyntax') {
@@ -155,102 +179,129 @@ class TdToken extends fixedToken(TrToken) {
 		return this;
 	}
 
+	/** @override */
 	afterBuild() {
 		if (this.#innerSyntax.includes('\0')) {
-			this.#innerSyntax = this.buildFromStr(this.#innerSyntax).map(String).join('');
+			this.#innerSyntax = this.getAttribute('buildFromStr')(this.#innerSyntax).map(String).join('');
 		}
 		return this;
 	}
 
-	static #aliases = {td: '\n|', th: '\n!', caption: '\n|+'};
-
-	/** @param {string} syntax */
-	setSyntax(syntax, esc = false) {
-		super.setSyntax(TdToken.#aliases[syntax] ?? syntax, esc);
+	/**
+	 * @override
+	 * @param {string} syntax 表格语法
+	 * @param {boolean} esc 是否需要转义
+	 */
+	setSyntax(syntax, esc) {
+		super.setSyntax(aliases[syntax] ?? syntax, esc);
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 修复\<td\>语法
+	 * @complexity `n`
+	 */
 	#correct() {
-		if (this.children[1].toString()) {
+		if (String(this.childNodes[1])) {
 			this.#innerSyntax ||= '|';
 		}
-		const {subtype, escape: esc, correction} = this.getSyntax();
+		const {subtype, escape, correction} = this.getSyntax();
 		if (correction) {
-			this.setSyntax(subtype, esc);
+			this.setSyntax(subtype, escape);
 		}
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 改为独占一行
+	 * @complexity `n`
+	 */
 	independence() {
 		if (!this.isIndependent()) {
-			const {subtype, escape: esc} = this.getSyntax();
-			this.setSyntax(subtype, esc);
+			const {subtype, escape} = this.getSyntax();
+			this.setSyntax(subtype, escape);
 		}
 	}
 
 	/**
+	 * @override
+	 * @param {string} selector
 	 * @returns {string}
 	 * @complexity `n`
 	 */
-	toString() {
+	toString(selector) {
 		this.#correct();
-		const [syntax, attr, inner] = this.children;
-		return `${syntax.toString()}${attr.toString()}${this.#innerSyntax}${inner.toString()}`;
+		const {childNodes: [syntax, attr, inner]} = this;
+		return selector && this.matches(selector)
+			? ''
+			: `${syntax.toString(selector)}${attr.toString(selector)}${this.#innerSyntax}${inner.toString(selector)}`;
 	}
 
+	/**
+	 * @override
+	 * @param {number} i 子节点位置
+	 */
 	getGaps(i = 0) {
 		i = i < 0 ? i + this.childNodes.length : i;
-		if (i !== 1) {
-			return 0;
+		if (i === 1) {
+			this.#correct();
+			return this.#innerSyntax.length;
 		}
-		this.#correct();
-		return this.#innerSyntax.length;
+		return 0;
+	}
+
+	/** @override */
+	print() {
+		const {childNodes: [syntax, attr, inner]} = this;
+		return `<span class="wpb-td">${syntax.print()}${attr.print()}${this.#innerSyntax}${inner.print()}</span>`;
 	}
 
 	/**
+	 * @override
 	 * @returns {string}
 	 * @complexity `n`
 	 */
 	text() {
 		this.#correct();
-		const [syntax, attr, inner] = this.children;
+		const {childNodes: [syntax, attr, inner]} = this;
 		return `${syntax.text()}${attr.text()}${this.#innerSyntax}${inner.text()}`;
 	}
 
 	/**
+	 * 获取单元格属性
 	 * @template {string} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {T extends 'rowspan'|'colspan' ? number : Record<string, string|true>}
 	 */
 	getAttr(key) {
 		const /** @type {string|true} */ value = super.getAttr(key);
 		key = key?.toLowerCase()?.trim();
-		return ['rowspan', 'colspan'].includes(key) ? Number(value) || 1 : value;
+		return key === 'rowspan' || key === 'colspan' ? Number(value) || 1 : value;
 	}
 
 	/**
+	 * 设置单元格属性
 	 * @template {string} T
-	 * @param {T} key
-	 * @param {T extends 'rowspan'|'colspan' ? number : string|boolean} value
+	 * @param {T} key 属性键
+	 * @param {T extends 'rowspan'|'colspan' ? number : string|boolean} value 属性值
 	 */
 	setAttr(key, value) {
 		if (typeof key !== 'string') {
 			this.typeError('setAttr', 'String');
 		}
 		key = key.toLowerCase().trim();
-		if (typeof value === 'number' && ['rowspan', 'colspan'].includes(key)) {
+		if (typeof value === 'number' && (key === 'rowspan' || key === 'colspan')) {
 			value = value === 1 ? false : String(value);
 		}
 		const /** @type {boolean} */ result = super.setAttr(key, value);
-		if (!this.children[1].toString()) {
+		if (!String(this.childNodes[1])) {
 			this.#innerSyntax = '';
 		}
 		return result;
 	}
 
+	/** @override */
 	escape() {
 		super.escape();
-		if (this.children[1].toString()) {
+		if (String(this.childNodes[1])) {
 			this.#innerSyntax ||= '{{!}}';
 		}
 		if (this.#innerSyntax === '|') {