wikiparser-node 0.11.0-m → 0.11.0

package/src/table/td.js

@@ -1,15 +1,26 @@
 'use strict';
 
+/**
+ * @template T
+ * @typedef {import('../../typings/node').TokenAttribute<T>} TokenAttribute
+ */
+
 const {generateForChild} = require('../../util/lint'),
+	fixedToken = require('../../mixin/fixedToken'),
+	{typeError} = require('../../util/debug'),
+	{isPlainObject} = require('../../util/base'),
 	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, AttributesToken, Token]}`
  */
-class TdToken extends TrToken {
+class TdToken extends fixedToken(TrToken) {
 	type = 'td';
 	#innerSyntax = '';
 
@@ -21,13 +32,46 @@ class TdToken extends TrToken {
 		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.firstChild.text()[0] === '\n';
+	}
+
 	/**
 	 * 获取单元格语法信息
-	 * @returns {{subtype: 'td'|'th'|'caption'}}
+	 * @returns {{subtype: 'td'|'th'|'caption', escape: boolean, correction: boolean}}
 	 * @complexity `n`
 	 */
 	getSyntax() {
 		const syntax = this.firstChild.text(),
+			esc = syntax.includes('{{'),
 			char = syntax.at(-1);
 		let subtype = 'td';
 		if (char === '!') {
@@ -35,7 +79,23 @@ class TdToken extends TrToken {
 		} else if (char === '+') {
 			subtype = 'caption';
 		}
-		return {subtype};
+		if (this.isIndependent()) {
+			return {subtype, escape: esc, correction: false};
+		}
+		const {previousSibling} = this;
+		if (previousSibling?.type !== 'td') {
+			return {subtype, escape: esc, correction: true};
+		}
+		const result = previousSibling.getSyntax();
+		result.escape ||= esc;
+		result.correction = previousSibling.lastChild
+			.toString('comment, ext, include, noinclude, arg, template, magic-word')
+			.includes('\n');
+		if (subtype === 'th' && result.subtype !== 'th') {
+			result.subtype = 'th';
+			result.correction = true;
+		}
+		return result;
 	}
 
 	/**
@@ -50,7 +110,7 @@ class TdToken extends TrToken {
 			innerSyntax = undefined;
 			attr = '';
 		}
-		super(syntax, attr, config, accum);
+		super(syntax, attr, config, accum, openingPattern);
 		if (innerSyntax) {
 			[this.#innerSyntax] = innerSyntax;
 		}
@@ -58,6 +118,8 @@ class TdToken extends TrToken {
 		const innerToken = new Token(inner?.slice(innerSyntax?.index + this.#innerSyntax.length), config, true, accum);
 		innerToken.type = 'td-inner';
 		this.insertAt(innerToken.setAttribute('stage', 4));
+		this.setAttribute('acceptable', {SyntaxToken: 0, AttributesToken: 1, Token: 2})
+			.seal(['getRowCount', 'getNthCol', 'insertTableCell'], true);
 	}
 
 	/** @override */
@@ -69,12 +131,16 @@ class TdToken extends TrToken {
 
 	/**
 	 * @override
+	 * @param {string} selector
 	 * @returns {string}
 	 * @complexity `n`
 	 */
 	toString(selector) {
+		this.#correct();
 		const {childNodes: [syntax, attr, inner]} = this;
-		return `${syntax.toString()}${attr.toString()}${this.#innerSyntax}${inner.toString()}`;
+		return selector && this.matches(selector)
+			? ''
+			: `${syntax.toString(selector)}${attr.toString(selector)}${this.#innerSyntax}${inner.toString(selector)}`;
 	}
 
 	/**
@@ -83,6 +149,7 @@ class TdToken extends TrToken {
 	 * @complexity `n`
 	 */
 	text() {
+		this.#correct();
 		const {childNodes: [syntax, attr, inner]} = this;
 		return `${syntax.text()}${attr.text()}${this.#innerSyntax}${inner.text()}`;
 	}
@@ -94,6 +161,7 @@ class TdToken extends TrToken {
 	getGaps(i = 0) {
 		i = i < 0 ? i + this.length : i;
 		if (i === 1) {
+			this.#correct();
 			return this.#innerSyntax.length;
 		}
 		return 0;
@@ -113,6 +181,163 @@ class TdToken extends TrToken {
 		}
 		return errors;
 	}
+
+	/** @override */
+	print() {
+		const {childNodes: [syntax, attr, inner]} = this;
+		return `<span class="wpb-td">${syntax.print()}${attr.print()}${this.#innerSyntax}${inner.print()}</span>`;
+	}
+
+	/** @override */
+	cloneNode() {
+		const /** @type {TdToken} */ token = super.cloneNode();
+		token.setAttribute('innerSyntax', this.#innerSyntax);
+		return token;
+	}
+
+	/**
+	 * 创建新的单元格
+	 * @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?.constructor !== Token || !isPlainObject(attr)) {
+			typeError(this, 'create', 'String', 'Token', 'Object');
+		} 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.lastChild.safeReplaceWith(inner);
+		for (const [k, v] of Object.entries(attr)) {
+			token.setAttr(k, v);
+		}
+		return token;
+	}
+
+	/**
+	 * @override
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		return key === 'innerSyntax' ? this.#innerSyntax : super.getAttribute(key);
+	}
+
+	/**
+	 * @override
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @param {TokenAttribute<T>} value 属性值
+	 * @returns {this}
+	 */
+	setAttribute(key, value) {
+		if (key === 'innerSyntax') {
+			this.#innerSyntax = String(value);
+			return this;
+		}
+		return super.setAttribute(key, value);
+	}
+
+	/**
+	 * @override
+	 * @param {string} syntax 表格语法
+	 * @param {boolean} esc 是否需要转义
+	 */
+	setSyntax(syntax, esc) {
+		super.setSyntax(aliases[syntax] ?? syntax, esc);
+	}
+
+	/**
+	 * 修复\<td\>语法
+	 * @complexity `n`
+	 */
+	#correct() {
+		if (String(this.childNodes[1])) {
+			this.#innerSyntax ||= '|';
+		}
+		const {subtype, escape, correction} = this.getSyntax();
+		if (correction) {
+			this.setSyntax(subtype, escape);
+		}
+	}
+
+	/**
+	 * 改为独占一行
+	 * @complexity `n`
+	 */
+	independence() {
+		if (!this.isIndependent()) {
+			const {subtype, escape} = this.getSyntax();
+			this.setSyntax(subtype, escape);
+		}
+	}
+
+	/**
+	 * 获取单元格属性
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @returns {T extends 'rowspan'|'colspan' ? number : string|true}
+	 */
+	getAttr(key) {
+		const /** @type {string|true} */ value = super.getAttr(key);
+		key = key?.toLowerCase()?.trim();
+		return key === 'rowspan' || key === 'colspan' ? Number(value) || 1 : value;
+	}
+
+	/**
+	 * 获取全部单元格属性
+	 * @returns {{rowspan: number, colspan: number, [key: string]: string|true}}
+	 */
+	getAttrs() {
+		const /** @type {record<string, string|true>} */ attr = super.getAttrs();
+		if ('rowspan' in attr) {
+			attr.rowspan = Number(attr.rowspan);
+		}
+		if ('colspan' in attr) {
+			attr.colspan = Number(attr.colspan);
+		}
+		return attr;
+	}
+
+	/**
+	 * 设置单元格属性
+	 * @template {string} T
+	 * @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' && (key === 'rowspan' || key === 'colspan')) {
+			value = value === 1 ? false : String(value);
+		}
+		const /** @type {boolean} */ result = super.setAttr(key, value);
+		if (!String(this.childNodes[1])) {
+			this.#innerSyntax = '';
+		}
+		return result;
+	}
+
+	/** @override */
+	escape() {
+		super.escape();
+		if (String(this.childNodes[1])) {
+			this.#innerSyntax ||= '{{!}}';
+		}
+		if (this.#innerSyntax === '|') {
+			this.#innerSyntax = '{{!}}';
+		}
+	}
 }
 
+Parser.classes.TdToken = __filename;
 module.exports = TdToken;

package/src/table/tr.js

@@ -1,16 +1,35 @@
 'use strict';
 
 const {generateForChild} = require('../../util/lint'),
+	attributeParent = require('../../mixin/attributeParent'),
 	Parser = require('../..'),
+	AstText = require('../../lib/text'),
 	Token = require('..'),
 	SyntaxToken = require('../syntax'),
 	AttributesToken = require('../attributes');
 
+const openingPattern = /^\n[^\S\n]*(?:\|-+|\{\{\s*!\s*\}\}-+|\{\{\s*!-\s*\}\}-*)$/u;
+
+/**
+ * 转义表格语法
+ * @param {SyntaxToken} syntax 表格语法节点
+ */
+const escapeTable = syntax => {
+	const templates = {'{|': '(!', '|}': '!)', '||': '!!', '|': '!'},
+		wikitext = syntax.childNodes.map(
+			child => child.type === 'text'
+				? String(child).replace(/\{\||\|\}|\|{2}|\|/gu, p => `{{${templates[p]}}}`)
+				: String(child),
+		).join(''),
+		token = Parser.parse(wikitext, syntax.getAttribute('include'), 2, syntax.getAttribute('config'));
+	syntax.replaceChildren(...token.childNodes);
+};
+
 /**
  * 表格行，含开头的换行，不含结尾的换行
  * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken]}`
  */
-class TrToken extends Token {
+class TrToken extends attributeParent(Token, 1) {
 	type = 'tr';
 
 	/**
@@ -19,14 +38,17 @@ class TrToken extends Token {
 	 * @param {import('../../typings/token').accum} accum
 	 * @param {RegExp} pattern 表格语法正则
 	 */
-	constructor(syntax, attr = '', config = Parser.getConfig(), accum = [], pattern = undefined) {
+	constructor(syntax, attr = '', config = Parser.getConfig(), accum = [], pattern = openingPattern) {
 		super(undefined, config, true, accum, {
+			Token: 2, SyntaxToken: 0, AttributesToken: 1, TdToken: '2:',
 		});
 		this.append(
 			new SyntaxToken(syntax, pattern, 'table-syntax', config, accum, {
+				'Stage-1': ':', '!ExtToken': '', TranscludeToken: ':',
 			}),
 			new AttributesToken(attr, 'table-attrs', this.type, config, accum),
 		);
+		this.getAttribute('protectChildren')(0, 1);
 	}
 
 	/**
@@ -66,9 +88,232 @@ class TrToken extends Token {
 
 	/** @override */
 	text() {
+		this.#correct();
 		const str = super.text();
 		return this.type === 'tr' && !str.trim().includes('\n') ? '' : str;
 	}
+
+	/**
+	 * @override
+	 * @this {TrToken & {constructor: typeof TrToken}}
+	 */
+	cloneNode() {
+		const [syntax, attr, inner, ...cloned] = this.cloneChildNodes();
+		return Parser.run(() => {
+			const token = new this.constructor(undefined, undefined, this.getAttribute('config'));
+			token.firstChild.safeReplaceWith(syntax);
+			token.childNodes[1].safeReplaceWith(attr);
+			if (token.type === 'td') { // TdToken
+				token.childNodes[2].safeReplaceWith(inner);
+			} else if (inner !== undefined) {
+				token.insertAt(inner);
+			}
+			token.append(...cloned);
+			return token;
+		});
+	}
+
+	/** 修复简单的表格语法错误 */
+	#correct() {
+		const {childNodes: [,, child]} = this;
+		if (child?.constructor === Token) {
+			const /** @type {{firstChild: AstText}} */ {firstChild} = child;
+			if (firstChild.type !== 'text') {
+				child.prepend('\n');
+			} else if (firstChild.data[0] !== '\n') {
+				firstChild.insertData(0, '\n');
+			}
+		}
+	}
+
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		this.#correct();
+		return super.toString(selector);
+	}
+
+	/**
+	 * 转义表格语法
+	 * @complexity `n`
+	 */
+	escape() {
+		for (const child of this.childNodes) {
+			if (child instanceof SyntaxToken) {
+				escapeTable(child);
+			} else if (child instanceof TrToken) {
+				child.escape();
+			}
+		}
+	}
+
+	/**
+	 * 设置表格语法
+	 * @param {string} syntax 表格语法
+	 * @param {boolean} esc 是否需要转义
+	 */
+	setSyntax(syntax, esc) {
+		const {firstChild} = this;
+		firstChild.replaceChildren(syntax);
+		if (esc) {
+			escapeTable(firstChild);
+		}
+	}
+
+	/**
+	 * @override
+	 * @param {number} i 移除位置
+	 * @complexity `n`
+	 */
+	removeAt(i) {
+		const TdToken = require('./td');
+		const child = this.childNodes.at(i);
+		if (child instanceof TdToken && child.isIndependent()) {
+			const {nextSibling} = child;
+			if (nextSibling?.type === 'td') {
+				nextSibling.independence();
+			}
+		}
+		return super.removeAt(i);
+	}
+
+	/**
+	 * @override
+	 * @template {AstText|Token} T
+	 * @param {T} token 待插入的子节点
+	 * @param {number} i 插入位置
+	 * @returns {T}
+	 * @complexity `n`
+	 */
+	insertAt(token, i = this.length) {
+		if (!Parser.running && !(token instanceof TrToken)) {
+			this.typeError('insertAt', 'TrToken');
+		}
+		const TdToken = require('./td');
+		const child = this.childNodes.at(i);
+		if (token instanceof TdToken && token.isIndependent() && child instanceof TdToken) {
+			child.independence();
+		}
+		return super.insertAt(token, i);
+	}
+
+	/**
+	 * 获取行数
+	 * @returns {0|1}
+	 * @complexity `n`
+	 */
+	getRowCount() {
+		const TdToken = require('./td');
+		return Number(this.childNodes.some(
+			child => child instanceof TdToken && child.isIndependent() && !child.firstChild.text().endsWith('+'),
+		));
+	}
+
+	/**
+	 * 获取相邻行
+	 * @param {(childNodes: Token[], index: number) => Token[]} subset 筛选兄弟节点的方法
+	 * @complexity `n`
+	 */
+	#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;
+	}
+
+	/**
+	 * 获取下一行
+	 * @complexity `n`
+	 */
+	getNextRow() {
+		return this.#getSiblingRow((childNodes, index) => childNodes.slice(index + 1));
+	}
+
+	/**
+	 * 获取前一行
+	 * @complexity `n`
+	 */
+	getPreviousRow() {
+		return this.#getSiblingRow((childNodes, index) => childNodes.slice(0, index).reverse());
+	}
+
+	/**
+	 * 获取列数
+	 * @complexity `n`
+	 */
+	getColCount() {
+		const TdToken = require('./td');
+		let count = 0,
+			last = 0;
+		for (const child of this.childNodes) {
+			if (child instanceof TdToken) {
+				last = child.isIndependent() ? Number(child.subtype !== 'caption') : last;
+				count += last;
+			}
+		}
+		return count;
+	}
+
+	/**
+	 * 获取第n列
+	 * @param {number} n 列号
+	 * @param {boolean} insert 是否用于判断插入新列的位置
+	 * @returns {TdToken}
+	 * @complexity `n`
+	 * @throws `RangeError` 不存在对应单元格
+	 */
+	getNthCol(n, insert) {
+		if (!Number.isInteger(n)) {
+			this.typeError('getNthCol', 'Number');
+		}
+		const nCols = this.getColCount();
+		n = n < 0 ? n + nCols : n;
+		if (n < 0 || n > nCols || n === nCols && !insert) {
+			throw new RangeError(`不存在第 ${n} 个单元格！`);
+		}
+		const TdToken = require('./td');
+		let last = 0;
+		for (const child of this.childNodes.slice(2)) {
+			if (child instanceof TdToken) {
+				if (child.isIndependent()) {
+					last = Number(child.subtype !== 'caption');
+				}
+				n -= last;
+				if (n < 0) {
+					return child;
+				}
+			} else if (child.type === 'tr' || child.type === 'table-syntax') {
+				return child;
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 * 插入新的单元格
+	 * @param {string|Token} inner 单元格内部wikitext
+	 * @param {import('../../typings/table').TableCoords} coord 单元格坐标
+	 * @param {'td'|'th'|'caption'} subtype 单元格类型
+	 * @param {Record<string, string|boolean>} attr 单元格属性
+	 * @returns {TdToken}
+	 * @complexity `n`
+	 */
+	insertTableCell(inner, {column}, subtype = 'td', attr = {}) {
+		const TdToken = require('./td');
+		const token = TdToken.create(inner, subtype, attr, this.getAttribute('include'), this.getAttribute('config'));
+		return this.insertBefore(token, this.getNthCol(column, true));
+	}
 }
 
+Parser.classes.TrToken = __filename;
 module.exports = TrToken;

package/src/tagPair/ext.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {generateForSelf} = require('../../util/lint'),
+	attributeParent = require('../../mixin/attributeParent'),
 	Parser = require('../..'),
 	Token = require('..'),
 	TagPairToken = require('.'),
@@ -10,7 +11,7 @@ const {generateForSelf} = require('../../util/lint'),
  * 扩展标签
  * @classdesc `{childNodes: [AttributesToken, NowikiToken|Token]}`
  */
-class ExtToken extends TagPairToken {
+class ExtToken extends attributeParent(TagPairToken) {
 	type = 'ext';
 	closed = true;
 
@@ -59,6 +60,11 @@ class ExtToken extends TagPairToken {
 				innerToken = new PreToken(inner, newConfig, accum);
 				break;
 			}
+			case 'charinsert': {
+				const CharinsertToken = require('../charinsert');
+				innerToken = new CharinsertToken(inner, newConfig, accum);
+				break;
+			}
 			case 'references': {
 				const ReferencesToken = require('../nested/references');
 				innerToken = new ReferencesToken(inner, newConfig, accum);
@@ -121,6 +127,20 @@ class ExtToken extends TagPairToken {
 		}
 		return errors;
 	}
+
+	/** @override */
+	cloneNode() {
+		const inner = this.lastChild.cloneNode(),
+			tags = this.getAttribute('tags'),
+			config = this.getAttribute('config'),
+			attr = String(this.firstChild);
+		return Parser.run(() => {
+			const token = new ExtToken(tags[0], attr, '', this.selfClosing ? undefined : tags[1], config);
+			token.lastChild.safeReplaceWith(inner);
+			return token;
+		});
+	}
 }
 
+Parser.classes.ExtToken = __filename;
 module.exports = ExtToken;

package/src/tagPair/include.js

@@ -21,6 +21,30 @@ class IncludeToken extends hidden(TagPairToken) {
 	constructor(name, attr = '', inner = undefined, closed = undefined, config = Parser.getConfig(), accum = []) {
 		super(name, attr, inner ?? '', inner === undefined ? closed : closed ?? '', config, accum);
 	}
+
+	/** @override */
+	cloneNode() {
+		const tags = this.getAttribute('tags'),
+			config = this.getAttribute('config'),
+			inner = this.selfClosing ? undefined : String(this.lastChild),
+			closing = this.selfClosing || !this.closed ? undefined : tags[1],
+			token = Parser.run(() => new IncludeToken(tags[0], String(this.firstChild), inner, closing, config));
+		return token;
+	}
+
+	/**
+	 * @override
+	 * @param {string} str 新文本
+	 */
+	setText(str) {
+		return super.setText(str, 1);
+	}
+
+	/** 清除标签属性 */
+	removeAttr() {
+		super.setText('', 0);
+	}
 }
 
+Parser.classes.IncludeToken = __filename;
 module.exports = IncludeToken;