wikiparser-node 0.11.0 → 1.0.0-b

package/src/converter.js

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

package/src/converterFlags.js

@@ -1,284 +0,0 @@
-'use strict';
-
-const {generateForChild} = require('../util/lint'),
-	Parser = require('..'),
-	Token = require('.'),
-	AtomToken = require('./atom');
-
-const definedFlags = new Set(['A', 'T', 'R', 'D', '-', 'H', 'N']);
-
-/**
- * 转换flags
- * @classdesc `{childNodes: ...AtomToken}`
- */
-class ConverterFlagsToken extends Token {
-	type = 'converter-flags';
-	/** @type {string[]} */ #flags;
-
-	/**
-	 * @param {string[]} flags 转换类型标记
-	 * @param {import('../typings/token').accum} accum
-	 */
-	constructor(flags, config = Parser.getConfig(), accum = []) {
-		super(undefined, config, true, accum, {
-			AtomToken: ':',
-		});
-		this.append(...flags.map(flag => new AtomToken(flag, 'converter-flag', config, accum)));
-	}
-
-	/**
-	 * @override
-	 * @complexity `n`
-	 */
-	afterBuild() {
-		this.#flags = this.childNodes.map(child => child.text().trim());
-		const /** @type {import('../typings/event').AstListener} */ converterFlagsListener = ({prevTarget}) => {
-			if (prevTarget) {
-				this.#flags[this.childNodes.indexOf(prevTarget)] = prevTarget.text().trim();
-			}
-		};
-		this.addEventListener(['remove', 'insert', 'text', 'replace'], converterFlagsListener);
-	}
-
-	/**
-	 * @override
-	 * @param {string} selector
-	 */
-	toString(selector) {
-		return super.toString(selector, ';');
-	}
-
-	/** @override */
-	text() {
-		return super.text(';');
-	}
-
-	/** @override */
-	getGaps() {
-		return 1;
-	}
-
-	/** @override */
-	print() {
-		return super.print({sep: ';'});
-	}
-
-	/**
-	 * @override
-	 * @param {number} start 起始位置
-	 */
-	lint(start = this.getAbsoluteIndex()) {
-		const variantFlags = this.getVariantFlags(),
-			unknownFlags = this.getUnknownFlags(),
-			validFlags = new Set(this.#flags.filter(flag => definedFlags.has(flag))),
-			{length: emptyFlagCount} = this.#flags.filter(flag => !flag),
-			knownFlagCount = this.#flags.length - unknownFlags.size - emptyFlagCount,
-			errors = super.lint(start);
-		if (variantFlags.size === knownFlagCount || validFlags.size === knownFlagCount) {
-			return errors;
-		}
-		const rect = {start, ...this.getRootNode().posFromIndex(start)},
-			{childNodes, length} = this;
-		for (let i = 0; i < length; i++) {
-			const child = childNodes[i],
-				flag = child.text().trim();
-			if (flag && !variantFlags.has(flag) && !unknownFlags.has(flag)
-				&& (variantFlags.size > 0 || !validFlags.has(flag))
-			) {
-				const error = generateForChild(child, rect, 'invalid conversion flag');
-				errors.push({...error, excerpt: childNodes.slice(0, i + 1).map(String).join(';').slice(-50)});
-			}
-		}
-		return errors;
-	}
-
-	/**
-	 * 获取未知转换类型标记
-	 * @complexity `n`
-	 */
-	getUnknownFlags() {
-		return new Set(this.#flags.filter(flag => /\{{3}[^{}]+\}{3}/u.test(flag)));
-	}
-
-	/** 获取指定语言变体的转换标记 */
-	getVariantFlags() {
-		const variants = new Set(this.getAttribute('config').variants);
-		return new Set(this.#flags.filter(flag => variants.has(flag)));
-	}
-
-	/** @override */
-	cloneNode() {
-		const cloned = this.cloneChildNodes();
-		return Parser.run(() => {
-			const token = new ConverterFlagsToken([], this.getAttribute('config'));
-			token.append(...cloned);
-			token.afterBuild();
-			return token;
-		});
-	}
-
-	/**
-	 * @override
-	 * @template {string} T
-	 * @param {T} key 属性键
-	 * @returns {import('../typings/node').TokenAttribute<T>}
-	 */
-	getAttribute(key) {
-		if (key === 'flags') {
-			return Parser.debugging ? this.#flags : [...this.#flags];
-		}
-		return super.getAttribute(key);
-	}
-
-	/**
-	 * @override
-	 * @param {PropertyKey} key 属性键
-	 */
-	hasAttribute(key) {
-		return key === 'flags' || super.hasAttribute(key);
-	}
-
-	/**
-	 * @override
-	 * @param {number} i 移除位置
-	 * @complexity `n`
-	 */
-	removeAt(i) {
-		const /** @type {AtomToken} */ token = super.removeAt(i);
-		this.#flags?.splice(i, 1);
-		return token;
-	}
-
-	/**
-	 * @override
-	 * @param {AtomToken} token 待插入的子节点
-	 * @param {number} i 插入位置
-	 * @complexity `n`
-	 */
-	insertAt(token, i = this.length) {
-		super.insertAt(token, i);
-		this.#flags?.splice(i, 0, token.text());
-		return token;
-	}
-
-	/** 获取所有转换类型标记 */
-	getAllFlags() {
-		return new Set(this.#flags);
-	}
-
-	/**
-	 * 获取转换类型标记节点
-	 * @param {string} flag 转换类型标记
-	 * @returns {AtomToken[]}
-	 * @complexity `n`
-	 */
-	getFlagToken(flag) {
-		return this.#flags.includes(flag) ? this.childNodes.filter(child => child.text().trim() === flag) : [];
-	}
-
-	/**
-	 * 获取有效转换类型标记
-	 * @complexity `n`
-	 */
-	getEffectiveFlags() {
-		const variantFlags = this.getVariantFlags(),
-			unknownFlags = this.getUnknownFlags();
-		if (variantFlags.size > 0) {
-			return new Set([...variantFlags, ...unknownFlags]);
-		}
-		const flags = new Set([...this.#flags.filter(flag => definedFlags.has(flag)), ...unknownFlags]);
-		if (flags.size === 0) {
-			return new Set('S');
-		} else if (flags.has('R')) {
-			return new Set('R');
-		} else if (flags.has('N')) {
-			return new Set('N');
-		} else if (flags.has('-')) {
-			return new Set('-');
-		} else if (flags.has('H')) {
-			const hasT = flags.has('T'),
-				hasD = flags.has('D');
-			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');
-		}
-		if (flags.has('A')) {
-			flags.add('+');
-			flags.add('S');
-		}
-		if (flags.has('D')) {
-			flags.delete('S');
-		}
-		return flags;
-	}
-
-	/**
-	 * 是否具有某转换类型标记
-	 * @param {string} flag 转换类型标记
-	 */
-	hasFlag(flag) {
-		return typeof flag === 'string' ? this.#flags.includes(flag) : this.typeError('hasFlag', 'String');
-	}
-
-	/**
-	 * 是否具有某有效转换类型标记
-	 * @param {string} flag 转换类型标记
-	 * @complexity `n`
-	 */
-	hasEffectiveFlag(flag) {
-		return typeof flag === 'string' ? this.getEffectiveFlags().has(flag) : this.typeError('hasFlag', 'String');
-	}
-
-	/**
-	 * 移除某转换类型标记
-	 * @param {string} flag 转换类型标记
-	 * @complexity `n²`
-	 */
-	removeFlag(flag) {
-		for (const token of this.getFlagToken(flag)) {
-			token.remove();
-		}
-	}
-
-	/**
-	 * 添加转换类型标记
-	 * @param {string} flag 转换类型标记
-	 * @complexity `n`
-	 */
-	#newFlag(flag) {
-		const token = Parser.run(() => new AtomToken(flag, 'converter-flag', this.getAttribute('config')));
-		this.insertAt(token);
-	}
-
-	/**
-	 * 设置转换类型标记
-	 * @param {string} flag 转换类型标记
-	 * @complexity `n`
-	 */
-	setFlag(flag) {
-		if (!this.#flags.includes(flag)) {
-			this.#newFlag(flag);
-		} else if (!this.getEffectiveFlags().has(flag)) {
-			Parser.error('此 flag 不会生效', flag);
-		}
-	}
-
-	/**
-	 * 开关转换类型标记
-	 * @param {string} flag 转换类型标记
-	 * @complexity `n²`
-	 */
-	toggleFlag(flag) {
-		if (this.#flags.includes(flag)) {
-			this.removeFlag(flag);
-		} else {
-			this.#newFlag(flag);
-		}
-	}
-}
-
-Parser.classes.ConverterFlagsToken = __filename;
-module.exports = ConverterFlagsToken;

package/src/converterRule.js

@@ -1,256 +0,0 @@
-'use strict';
-
-const Parser = require('..'),
-	{undo} = require('../util/debug'),
-	{noWrap} = require('../util/string'),
-	Token = require('.'),
-	AtomToken = require('./atom');
-
-/**
- * 转换规则
- * @classdesc `{childNodes: ...AtomToken)}`
- */
-class ConverterRuleToken extends Token {
-	type = 'converter-rule';
-
-	/** 语言变体 */
-	get variant() {
-		return this.childNodes.at(-2)?.text()?.trim() ?? '';
-	}
-
-	set variant(variant) {
-		this.setVariant(variant);
-	}
-
-	/** 是否是单向转换 */
-	get unidirectional() {
-		return this.length === 3;
-	}
-
-	set unidirectional(unidirectional) {
-		if (unidirectional === false) {
-			this.makeBidirectional();
-		}
-	}
-
-	/** 是否是双向转换 */
-	get bidirectional() {
-		return this.length === 2;
-	}
-
-	/**
-	 * @param {string} rule 转换规则
-	 * @param {boolean} hasColon 是否带有":"
-	 * @param {import('../typings/token').accum} accum
-	 */
-	constructor(rule, hasColon = true, config = Parser.getConfig(), accum = []) {
-		super(undefined, config, true, accum);
-		if (hasColon) {
-			const i = rule.indexOf(':'),
-				j = rule.slice(0, i).indexOf('=>'),
-				v = j === -1 ? rule.slice(0, i) : rule.slice(j + 2, i);
-			if (config.variants.includes(v.trim())) {
-				super.insertAt(new AtomToken(v, 'converter-rule-variant', config, accum));
-				super.insertAt(new AtomToken(rule.slice(i + 1), 'converter-rule-to', config, accum));
-				if (j !== -1) {
-					super.insertAt(new AtomToken(rule.slice(0, j), 'converter-rule-from', config, accum), 0);
-				}
-			} else {
-				super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
-			}
-		} else {
-			super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
-		}
-		this.getAttribute('protectChildren')('1:');
-	}
-
-	/**
-	 * @override
-	 * @param {string} selector
-	 * @returns {string}
-	 */
-	toString(selector) {
-		if (this.length === 3 && !(selector && this.matches(selector))) {
-			const {childNodes: [from, variant, to]} = this;
-			return `${from.toString(selector)}=>${variant.toString(selector)}:${to.toString(selector)}`;
-		}
-		return super.toString(selector, ':');
-	}
-
-	/**
-	 * @override
-	 * @returns {string}
-	 */
-	text() {
-		if (this.length === 3) {
-			const {childNodes: [from, variant, to]} = this;
-			return `${from.text()}=>${variant.text()}:${to.text()}`;
-		}
-		return super.text(':');
-	}
-
-	/**
-	 * @override
-	 * @param {number} i 子节点序号
-	 */
-	getGaps(i = 0) {
-		const {length} = this;
-		i = i < 0 ? i + length : i;
-		return i === 0 && length === 3 ? 2 : 1;
-	}
-
-	/** @override */
-	print() {
-		if (this.length === 3) {
-			const {childNodes: [from, variant, to]} = this;
-			return `<span class="wpb-converter-rule">${from.print()}=>${variant.print()}:${to.print()}</span>`;
-		}
-		return super.print({sep: ':'});
-	}
-
-	/** @override */
-	cloneNode() {
-		const cloned = this.cloneChildNodes(),
-			placeholders = ['', 'zh:', '=>zh:'],
-			placeholder = placeholders[cloned.length - 1];
-		return Parser.run(() => {
-			const token = new ConverterRuleToken(placeholder, placeholder, this.getAttribute('config'));
-			for (let i = 0; i < cloned.length; i++) {
-				token.childNodes[i].safeReplaceWith(cloned[i]);
-			}
-			token.afterBuild();
-			return token;
-		});
-	}
-
-	/** @override */
-	afterBuild() {
-		const /** @type {import('../typings/event').AstListener} */ converterRuleListener = (e, data) => {
-			const {prevTarget} = e;
-			if (this.length > 1 && this.childNodes.at(-2) === prevTarget) {
-				const v = prevTarget.text().trim(),
-					{variants} = this.getAttribute('config');
-				if (!variants.includes(v)) {
-					undo(e, data);
-					throw new Error(`无效的语言变体：${v}`);
-				}
-			}
-		};
-		this.addEventListener(['remove', 'insert', 'text', 'replace'], converterRuleListener);
-	}
-
-	/**
-	 * @override
-	 * @param {number} i 移除位置
-	 * @returns {AtomToken}
-	 * @throws `Error` 至少保留1个子节点
-	 */
-	removeAt(i) {
-		if (this.length === 1) {
-			throw new Error(`${this.constructor.name} 需至少保留 1 个子节点！`);
-		}
-		const removed = super.removeAt(i);
-		if (this.length === 1) {
-			this.firstChild.type = 'converter-rule-noconvert';
-		}
-		return removed;
-	}
-
-	/**
-	 * @override
-	 * @throws `Error` 请勿手动插入子节点
-	 */
-	insertAt() {
-		throw new Error(`转换规则语法复杂，请勿尝试对 ${this.constructor.name} 手动插入子节点！`);
-	}
-
-	/** 修改为不转换 */
-	noConvert() {
-		const {length} = this;
-		for (let i = 0; i < length - 1; i++) { // ConverterRuleToken只能从前往后删除子节点
-			this.removeAt(0);
-		}
-	}
-
-	/**
-	 * 设置转换目标
-	 * @param {string} to 转换目标
-	 * @throws `SyntaxError` 非法的转换目标
-	 */
-	setTo(to) {
-		to = String(to);
-		const config = this.getAttribute('config'),
-			root = Parser.parse(`-{|${config.variants[0]}:${to}}-`, this.getAttribute('include'), undefined, config),
-			{length, firstChild: converter} = root,
-			{lastChild: converterRule, type, length: converterLength} = converter;
-		if (length !== 1 || type !== 'converter' || converterLength !== 2 || converterRule.length !== 2) {
-			throw new SyntaxError(`非法的转换目标：${noWrap(to)}`);
-		}
-		const {lastChild} = converterRule;
-		converterRule.destroy();
-		this.lastChild.safeReplaceWith(lastChild);
-	}
-
-	/**
-	 * 设置语言变体
-	 * @param {string} variant 语言变体
-	 * @throws `RangeError` 无效的语言变体
-	 */
-	setVariant(variant) {
-		if (typeof variant !== 'string') {
-			this.typeError('setVariant', 'String');
-		}
-		const config = this.getAttribute('config'),
-			v = variant.trim();
-		if (!config.variants.includes(v)) {
-			throw new RangeError(`无效的语言变体：${v}`);
-		} else if (this.length === 1) {
-			super.insertAt(Parser.run(() => new AtomToken(variant, 'converter-rule-variant', config)), 0);
-		} else {
-			this.childNodes.at(-2).setText(variant);
-		}
-	}
-
-	/**
-	 * 设置转换原文
-	 * @param {string} from 转换原文
-	 * @throws `Error` 尚未指定语言变体
-	 * @throws `SyntaxError` 非法的转换原文
-	 */
-	setFrom(from) {
-		const {variant, unidirectional} = this;
-		if (!variant) {
-			throw new Error('请先指定语言变体！');
-		}
-		from = String(from);
-		const config = this.getAttribute('config'),
-			root = Parser.parse(`-{|${from}=>${variant}:}-`, this.getAttribute('include'), undefined, config),
-			{length, firstChild: converter} = root,
-			{type, length: converterLength, lastChild: converterRule} = converter;
-		if (length !== 1 || type !== 'converter' || converterLength !== 2 || converterRule.length !== 3) {
-			throw new SyntaxError(`非法的转换原文：${noWrap(from)}`);
-		} else if (unidirectional) {
-			this.firstChild.safeReplaceWith(converterRule.firstChild);
-		} else {
-			super.insertAt(converterRule.firstChild, 0);
-		}
-	}
-
-	/**
-	 * 修改为单向转换
-	 * @param {string} from 转换来源
-	 */
-	makeUnidirectional(from) {
-		this.setFrom(from);
-	}
-
-	/** 修改为双向转换 */
-	makeBidirectional() {
-		if (this.unidirectional) {
-			this.removeAt(0);
-		}
-	}
-}
-
-Parser.classes.ConverterRuleToken = __filename;
-module.exports = ConverterRuleToken;