wikiparser-node 0.3.1 → 0.5.0

package/src/converter.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const {text} = require('../util/string'),
-	/** @type {Parser} */ Parser = require('..'),
+const {text, print} = require('../util/string'),
+	Parser = require('..'),
 	Token = require('.'),
 	ConverterFlagsToken = require('./converterFlags'),
 	ConverterRuleToken = require('./converterRule');
@@ -14,116 +14,151 @@ class ConverterToken extends Token {
 	type = 'converter';
 
 	/**
-	 * @param {string[]} flags
-	 * @param {string[]} rules
+	 * 是否无转换
+	 * @this {ConverterToken & {lastChild: ConverterRuleToken}}
+	 */
+	get noConvert() {
+		return this.hasFlag('R') || this.childNodes.length === 2 && !this.lastChild.variant;
+	}
+
+	/**
+	 * @param {string[]} flags 转换类型标记
+	 * @param {string[]} rules 转换规则
 	 * @param {accum} accum
 	 */
 	constructor(flags, rules, config = Parser.getConfig(), accum = []) {
 		super(undefined, config, true, accum);
 		this.append(new ConverterFlagsToken(flags, config, accum));
-		if (rules.length) {
-			const [firstRule] = rules,
-				hasColon = firstRule.includes(':'),
-				firstRuleToken = new ConverterRuleToken(firstRule, hasColon, config, accum);
-			if (hasColon && firstRuleToken.childNodes.length === 1) {
-				this.appendChild(new ConverterRuleToken(rules.join(';'), false, config, accum));
-			} else {
-				this.append(
-					firstRuleToken,
-					...rules.slice(1).map(rule => new ConverterRuleToken(rule, true, config, accum)),
-				);
-			}
+		const [firstRule] = rules,
+			hasColon = firstRule.includes(':'),
+			firstRuleToken = new ConverterRuleToken(firstRule, hasColon, config, accum);
+		if (hasColon && firstRuleToken.childNodes.length === 1) {
+			this.appendChild(new ConverterRuleToken(rules.join(';'), false, config, accum));
+		} else {
+			this.append(
+				firstRuleToken,
+				...rules.slice(1).map(rule => new ConverterRuleToken(rule, true, config, accum)),
+			);
 		}
-		this.protectChildren(0);
+		this.getAttribute('protectChildren')(0);
 	}
 
+	/** @override */
 	cloneNode() {
-		const [flags, ...rules] = this.cloneChildren(),
+		const [flags, ...rules] = this.cloneChildNodes(),
 			token = Parser.run(() => new ConverterToken([], [], this.getAttribute('config')));
-		token.firstElementChild.safeReplaceWith(flags);
+		token.firstChild.safeReplaceWith(flags);
 		token.append(...rules);
 		return token;
 	}
 
-	toString() {
-		const [flags, ...rules] = this.children;
-		return `-{${flags.toString()}${flags.childNodes.length ? '|' : ''}${rules.map(String).join(';')}}-`;
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		const {childNodes: [flags, ...rules]} = this;
+		return selector && this.matches(selector)
+			? ''
+			: `-{${flags.toString(selector)}${flags.childNodes.length > 0 ? '|' : ''}${rules.map(String).join(';')}}-`;
 	}
 
+	/** @override */
 	getPadding() {
 		return 2;
 	}
 
-	/** @param {number} i */
+	/**
+	 * /** @override
+	 * @param {number} i 子节点位置
+	 */
 	getGaps(i = 0) {
 		i = i < 0 ? i + this.childNodes.length : i;
-		return i || this.firstElementChild.childNodes.length ? 1 : 0;
+		return i || this.firstChild.childNodes.length > 0 ? 1 : 0;
+	}
+
+	/** @override */
+	print() {
+		const {children: [flags, ...rules]} = this;
+		return `<span class="wpb-converter">-{${flags.print()}${
+			flags.childNodes.length > 0 ? '|' : ''
+		}${print(rules, {sep: ';'})}}-</span>`;
 	}
 
+	/** @override */
 	text() {
-		const [flags, ...rules] = this.children;
+		const {childNodes: [flags, ...rules]} = this;
 		return `-{${flags.text()}|${text(rules, ';')}}-`;
 	}
 
-	/** @this {ConverterToken & {firstChild: ConverterFlagsToken}} */
+	/**
+	 * 获取所有转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 */
 	getAllFlags() {
 		return this.firstChild.getAllFlags();
 	}
 
-	/** @this {ConverterToken & {firstChild: ConverterFlagsToken}} */
+	/**
+	 * 获取有效的转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 */
 	getEffectiveFlags() {
 		return this.firstChild.getEffectiveFlags();
 	}
 
-	/** @this {ConverterToken & {firstChild: ConverterFlagsToken}} */
+	/**
+	 * 获取未知的转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 */
 	getUnknownFlags() {
 		return this.firstChild.getUnknownFlags();
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 是否具有某转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	hasFlag(flag) {
 		return this.firstChild.hasFlag(flag);
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 是否具有某有效的转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	hasEffectiveFlag(flag) {
 		return this.firstChild.hasEffectiveFlag(flag);
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 移除转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	removeFlag(flag) {
 		this.firstChild.removeFlag(flag);
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 设置转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	setFlag(flag) {
 		this.firstChild.setFlag(flag);
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 开关某转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	toggleFlag(flag) {
 		this.firstChild.toggleFlag(flag);
 	}
-
-	/** @this {ConverterToken & {children: [ConverterFlagsToken, ConverterRuleToken]}} */
-	get noConvert() {
-		return this.childNodes.length < 3 && !this.children[1]?.variant;
-	}
 }
 
 Parser.classes.ConverterToken = __filename;

package/src/converterFlags.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const /** @type {Parser} */ Parser = require('..'),
+const {generateForChild} = require('../util/lint'),
+	Parser = require('..'),
 	Token = require('.'),
 	AtomToken = require('./atom');
 
@@ -13,7 +14,7 @@ class ConverterFlagsToken extends Token {
 	/** @type {string[]} */ #flags;
 
 	/**
-	 * @param {string[]} flags
+	 * @param {string[]} flags 转换类型标记
 	 * @param {accum} accum
 	 */
 	constructor(flags, config = Parser.getConfig(), accum = []) {
@@ -21,30 +22,34 @@ class ConverterFlagsToken extends Token {
 		this.append(...flags.map(flag => new AtomToken(flag, 'converter-flag', config, accum)));
 	}
 
+	/** @override */
 	cloneNode() {
-		const cloned = this.cloneChildren(),
+		const cloned = this.cloneChildNodes(),
 			token = Parser.run(() => new ConverterFlagsToken([], this.getAttribute('config')));
 		token.append(...cloned);
 		token.afterBuild();
 		return token;
 	}
 
-	/** @complexity `n` */
+	/**
+	 * @override
+	 * @complexity `n`
+	 */
 	afterBuild() {
-		this.#flags = this.children.map(child => child.text().trim());
-		const that = this,
-			/** @type {AstListener} */ converterFlagsListener = ({prevTarget}) => {
-				if (prevTarget) {
-					that.#flags[that.childNodes.indexOf(prevTarget)] = prevTarget.text().trim();
-				}
-			};
+		this.#flags = this.childNodes.map(child => child.text().trim());
+		const /** @type {AstListener} */ converterFlagsListener = ({prevTarget}) => {
+			if (prevTarget) {
+				this.#flags[this.childNodes.indexOf(prevTarget)] = prevTarget.text().trim();
+			}
+		};
 		this.addEventListener(['remove', 'insert', 'text', 'replace'], converterFlagsListener);
 		return this;
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {TokenAttribute<T>}
 	 */
 	getAttribute(key) {
@@ -55,7 +60,8 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {number} i
+	 * @override
+	 * @param {number} i 移除位置
 	 * @complexity `n`
 	 */
 	removeAt(i) {
@@ -65,7 +71,9 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {AtomToken} token
+	 * @override
+	 * @param {AtomToken} token 待插入的子节点
+	 * @param {number} i 插入位置
 	 * @complexity `n`
 	 */
 	insertAt(token, i = this.childNodes.length) {
@@ -74,42 +82,92 @@ class ConverterFlagsToken extends Token {
 		return token;
 	}
 
-	toString() {
-		return super.toString(';');
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		return super.toString(selector, ';');
 	}
 
+	/** @override */
 	getGaps() {
 		return 1;
 	}
 
+	/** @override */
+	print() {
+		return super.print({sep: ';'});
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const variantFlags = this.getVariantFlags(),
+			unknownFlags = this.getUnknownFlags(),
+			emptyFlags = this.#flags.filter(flag => !flag),
+			validFlags = this.#flags.filter(flag => ['A', 'T', 'R', 'D', '-', 'H', 'N'].includes(flag)),
+			knownFlagCount = this.#flags.length - unknownFlags.length - emptyFlags,
+			errors = super.lint(start);
+		if (variantFlags.length === knownFlagCount || validFlags.length === knownFlagCount) {
+			return errors;
+		}
+		const rect = this.getRootNode().posFromIndex(start);
+		for (const child of this.childNodes) {
+			const flag = child.text().trim();
+			if (flag && !variantFlags.includes(flag) && !unknownFlags.includes(flag)
+				&& (variantFlags.length > 0 || !validFlags.includes(flag))
+			) {
+				errors.push(generateForChild(child, rect, '无效的转换标记'));
+			}
+		}
+		return errors;
+	}
+
+	/** @override */
 	text() {
 		return super.text(';');
 	}
 
 	/**
-	 * @param {string} flag
+	 * 获取转换类型标记节点
+	 * @param {string} flag 转换类型标记
 	 * @returns {AtomToken[]}
 	 * @complexity `n`
 	 */
 	getFlagToken(flag) {
-		return this.#flags.includes(flag) ? this.children.filter(child => child.text().trim() === flag) : [];
+		return this.#flags.includes(flag) ? this.childNodes.filter(child => child.text().trim() === flag) : [];
 	}
 
+	/** 获取所有转换类型标记 */
 	getAllFlags() {
 		return new Set(this.#flags);
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取未知转换类型标记
+	 * @complexity `n`
+	 */
 	getUnknownFlags() {
-		return this.#flags.filter(flag => /\{\{[^{}]+\}\}/.test(flag));
+		return this.#flags.filter(flag => /\{\{[^{}]+\}\}/u.test(flag));
+	}
+
+	/** 获取指定语言变体的转换标记 */
+	getVariantFlags() {
+		const {variants} = this.getAttribute('config');
+		return this.#flags.filter(flag => variants.includes(flag));
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取有效转换类型标记
+	 * @complexity `n`
+	 */
 	getEffectiveFlags() {
-		const {variants} = this.getAttribute('config'),
-			variantFlags = this.#flags.filter(flag => variants.includes(flag)),
+		const variantFlags = this.getVariantFlags(),
 			unknownFlags = this.getUnknownFlags();
-		if (variantFlags.length) {
+		if (variantFlags.length > 0) {
 			return new Set([...variantFlags, ...unknownFlags]);
 		}
 		const validFlags = ['A', 'T', 'R', 'D', '-', 'H', 'N'],
@@ -125,10 +183,9 @@ class ConverterFlagsToken extends Token {
 		} else if (flags.has('H')) {
 			const hasT = flags.has('T'),
 				hasD = flags.has('D');
-			if (hasT && hasD) {
-				return new Set(['+', 'H', 'T', 'D']);
-			}
-			return new Set(['+', 'H', ...hasT ? ['T'] : [], ...hasD ? ['D'] : [], ...unknownFlags]);
+			return hasT && hasD
+				? new Set(['+', 'H', 'T', 'D'])
+				: new Set(['+', 'H', ...hasT ? ['T'] : [], ...hasD ? ['D'] : [], ...unknownFlags]);
 		}
 		if (flags.size === 1 && flags.has('T')) {
 			flags.add('H');
@@ -143,27 +200,26 @@ class ConverterFlagsToken extends Token {
 		return flags;
 	}
 
-	/** @param {string} flag */
+	/**
+	 * 是否具有某转换类型标记
+	 * @param {string} flag 转换类型标记
+	 */
 	hasFlag(flag) {
-		if (typeof flag !== 'string') {
-			this.typeError('hasFlag', 'String');
-		}
-		return this.#flags.includes(flag);
+		return typeof flag === 'string' ? this.#flags.includes(flag) : this.typeError('hasFlag', 'String');
 	}
 
 	/**
-	 * @param {string} flag
+	 * 是否具有某有效转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n`
 	 */
 	hasEffectiveFlag(flag) {
-		if (typeof flag !== 'string') {
-			this.typeError('hasFlag', 'String');
-		}
-		return this.getEffectiveFlags().has(flag);
+		return typeof flag === 'string' ? this.getEffectiveFlags().has(flag) : this.typeError('hasFlag', 'String');
 	}
 
 	/**
-	 * @param {string} flag
+	 * 移除某转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n²`
 	 */
 	removeFlag(flag) {
@@ -173,7 +229,8 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {string} flag
+	 * 添加转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n`
 	 */
 	#newFlag(flag) {
@@ -182,7 +239,8 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {string} flag
+	 * 设置转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n`
 	 */
 	setFlag(flag) {
@@ -194,14 +252,15 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {string} flag
+	 * 开关转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n²`
 	 */
 	toggleFlag(flag) {
-		if (!this.#flags.includes(flag)) {
-			this.#newFlag(flag);
-		} else {
+		if (this.#flags.includes(flag)) {
 			this.removeFlag(flag);
+		} else {
+			this.#newFlag(flag);
 		}
 	}
 }