wikiparser-node 0.0.0

package/src/nowiki/noinclude.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const hidden = require('../../mixin/hidden'),
+	/** @type {Parser} */ Parser = require('../..'),
+	NowikiToken = require('.');
+
+/**
+ * `<noinclude>`和`</noinclude>`，不可进行任何更改
+ * @classdesc `{childNodes: [string]}`
+ */
+class NoincludeToken extends hidden(NowikiToken) {
+	type = 'noinclude';
+
+	/** @param {string} str */
+	setText(str) {
+		if (/^<\/?(?:(?:no|only)include|includeonly)(?:\s.*)?\/?>$/is.test(this.toString())) {
+			throw new Error(`${this.constructor.name} 不可更改文字内容！`);
+		}
+		return super.setText(str);
+	}
+}
+
+Parser.classes.NoincludeToken = __filename;
+module.exports = NoincludeToken;

package/src/nowiki/quote.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('../..'),
+	NowikiToken = require('.');
+
+/**
+ * `<hr>`
+ * @classdesc `{childNodes: [string]}`
+ */
+class QuoteToken extends NowikiToken {
+	type = 'quote';
+
+	/**
+	 * @param {number} n
+	 * @param {accum} accum
+	 */
+	constructor(n, config = Parser.getConfig(), accum = []) {
+		super("'".repeat(n), config, accum);
+		this.setAttribute('name', String(n));
+	}
+
+	/** @param {string} str */
+	setText(str) {
+		if (!["''", "'''", "'''''"].includes(str)) {
+			throw new RangeError(`${this.constructor.name} 的内部文本只能为连续 2/3/5 个"'"！`);
+		}
+		return super.setText(str);
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return [];
+	}
+}
+
+Parser.classes.QuoteToken = __filename;
+module.exports = QuoteToken;

package/src/onlyinclude.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 嵌入时的`<onlyinclude>`
+ * @classdesc `{childNodes: ...string|Token}`
+ */
+class OnlyincludeToken extends Token {
+	type = 'onlyinclude';
+
+	/**
+	 * @param {string} inner
+	 * @param {accum} accum
+	 */
+	constructor(inner, config = Parser.getConfig(), accum = []) {
+		super(inner, config, false, accum);
+	}
+
+	cloneNode() {
+		const cloned = this.cloneChildren(),
+			token = Parser.run(() => new OnlyincludeToken(undefined, this.getAttribute('config')));
+		token.append(...cloned);
+		return token;
+	}
+
+	toString() {
+		return `<onlyinclude>${super.toString()}</onlyinclude>`;
+	}
+
+	getPadding() {
+		return 13;
+	}
+
+	isPlain() {
+		return this.constructor === OnlyincludeToken;
+	}
+}
+
+Parser.classes.OnlyincludeToken = __filename;
+module.exports = OnlyincludeToken;

package/src/parameter.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const {typeError} = require('../util/debug'),
+	fixedToken = require('../mixin/fixedToken'),
+	/** @type {Parser} */ Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 模板或魔术字参数
+ * @classdesc `{childNodes: [AtomToken, Token]}`
+ */
+class ParameterToken extends fixedToken(Token) {
+	type = 'parameter';
+	anon;
+
+	/**
+	 * @param {string|number} key
+	 * @param {string} value
+	 * @param {accum} accum
+	 */
+	constructor(key, value, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum);
+		this.anon = typeof key === 'number';
+		const AtomToken = require('./atom'),
+			keyToken = new AtomToken(this.anon ? undefined : key, 'parameter-key', config, accum, {
+				'Stage-2': ':', '!HeadingToken': '',
+			}),
+			token = new Token(value, config, true, accum);
+		token.type = 'parameter-value';
+		this.append(keyToken, token.setAttribute('stage', 2));
+	}
+
+	cloneNode() {
+		const [key, value] = this.cloneChildren(),
+			config = this.getAttribute('config');
+		return Parser.run(() => {
+			const token = new ParameterToken(this.anon ? Number(this.name) : undefined, undefined, config);
+			token.firstElementChild.safeReplaceWith(key);
+			token.lastElementChild.safeReplaceWith(value);
+			return token.afterBuild();
+		});
+	}
+
+	afterBuild() {
+		if (!this.anon) {
+			const name = this.firstElementChild.text().trim(),
+				{parentNode} = this;
+			this.setAttribute('name', name);
+			if (parentNode && parentNode instanceof require('./transclude')) {
+				parentNode.getAttribute('keys').add(name);
+				parentNode.getArgs(name, false, false).add(this);
+			}
+		}
+		const that = this;
+		/**
+		 * 在AstEventData中记录`oldKey`和`newKey`
+		 * @type {AstListener}
+		 */
+		const parameterListener = ({prevTarget}, data) => {
+			if (!that.anon) { // 匿名参数不管怎么变动还是匿名
+				const {firstElementChild} = that;
+				if (prevTarget === firstElementChild) {
+					const newKey = firstElementChild.text().trim();
+					data.oldKey = that.name;
+					data.newKey = newKey;
+					that.setAttribute('name', newKey);
+				}
+			}
+		};
+		this.addEventListener(['remove', 'insert', 'replace', 'text'], parameterListener);
+		return this;
+	}
+
+	/** @returns {string} */
+	toString() {
+		return this.anon ? this.lastElementChild.toString() : super.toString('=');
+	}
+
+	getGaps() {
+		return this.anon ? 0 : 1;
+	}
+
+	/** @returns {string} */
+	text() {
+		return this.anon ? this.lastElementChild.text() : super.text('=');
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return this.lastElementChild.plain();
+	}
+
+	/**
+	 * @param {ParameterToken} token
+	 * @complexity `n`
+	 */
+	safeReplaceWith(token) {
+		Parser.warn(`${this.constructor.name}.safeReplaceWith 方法退化到 replaceWith。`);
+		return this.replaceWith(token);
+	}
+
+	getValue() {
+		const value = this.lastElementChild.text();
+		return this.anon && this.parentNode?.matches('template, magic-word#invoke') ? value : value.trim();
+	}
+
+	/** @param {string} value */
+	setValue(value) {
+		value = String(value);
+		const templateLike = this.parentElement?.matches('template, magic-word#invoke'),
+			wikitext = `{{${templateLike ? ':T|' : 'lc:'}${this.anon ? '' : '1='}${value}}}`,
+			root = Parser.parse(wikitext, this.getAttribute('include'), 2, this.getAttribute('config')),
+			{childNodes: {length}, firstElementChild} = root,
+			/** @type {ParameterToken} */ lastElementChild = firstElementChild?.lastElementChild;
+		if (length !== 1 || !firstElementChild?.matches(templateLike ? 'template#T' : 'magic-word#lc')
+			|| firstElementChild.childElementCount !== 2
+			|| lastElementChild.anon !== this.anon || lastElementChild.name !== '1'
+		) {
+			throw new SyntaxError(`非法的模板参数：${value.replaceAll('\n', '\\n')}`);
+		}
+		const newValue = lastElementChild.lastChild;
+		root.destroy();
+		firstElementChild.destroy();
+		lastElementChild.destroy();
+		this.lastElementChild.safeReplaceWith(newValue);
+	}
+
+	/** @param {string} key */
+	rename(key, force = false) {
+		if (typeof key !== 'string') {
+			typeError(this, 'rename', 'String');
+		}
+		const {parentNode} = this;
+		// 必须检测是否是TranscludeToken
+		if (!parentNode || !parentNode.matches('template, magic-word#invoke')
+			|| !(parentNode instanceof require('./transclude'))
+		) {
+			throw new Error(`${this.constructor.name}.rename 方法仅用于模板参数！`);
+		}
+		const root = Parser.parse(`{{:T|${key}=}}`, this.getAttribute('include'), 2, this.getAttribute('config')),
+			{childNodes: {length}, firstElementChild} = root;
+		if (length !== 1 || !firstElementChild?.matches('template#T') || firstElementChild.childElementCount !== 2) {
+			throw new SyntaxError(`非法的模板参数名：${key}`);
+		}
+		const {lastElementChild} = firstElementChild,
+			{name} = lastElementChild,
+			keyToken = lastElementChild.firstChild;
+		if (this.name === name) {
+			Parser.warn('未改变实际参数名', name);
+		} else if (parentNode.hasArg(name)) {
+			if (force) {
+				Parser.warn('参数更名造成重复参数', name);
+			} else {
+				throw new RangeError(`参数更名造成重复参数：${name}`);
+			}
+		}
+		root.destroy();
+		firstElementChild.destroy();
+		lastElementChild.destroy();
+		this.firstElementChild.safeReplaceWith(keyToken);
+	}
+}
+
+Parser.classes.ParameterToken = __filename;
+module.exports = ParameterToken;

package/src/syntax.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const {undo} = require('../util/debug'),
+	{text} = require('../util/string'),
+	/** @type {Parser} */ Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 满足特定语法格式的plain Token
+ * @classdesc `{childNodes: (string|Token)[]}`
+ */
+class SyntaxToken extends Token {
+	#pattern;
+
+	/**
+	 * @param {?string} wikitext
+	 * @param {RegExp} pattern
+	 * @param {accum} accum
+	 * @param {acceptable} acceptable
+	 */
+	constructor(wikitext, pattern, type = 'plain', config = Parser.getConfig(), accum = [], acceptable = null) {
+		super(wikitext, config, true, accum, acceptable);
+		this.type = type;
+		this.#pattern = pattern;
+	}
+
+	cloneNode() {
+		const cloned = this.cloneChildren(),
+			config = this.getAttribute('config'),
+			acceptable = this.getAttribute('acceptable');
+		return Parser.run(() => {
+			const token = new SyntaxToken(undefined, this.#pattern, this.type, config, [], acceptable);
+			token.append(...cloned);
+			return token.afterBuild();
+		});
+	}
+
+	afterBuild() {
+		const that = this,
+			/** @type {AstListener} */ syntaxListener = (e, data) => {
+				if (!Parser.running && !that.#pattern.test(that.text())) {
+					undo(e, data);
+				}
+			};
+		this.addEventListener(['remove', 'insert', 'replace', 'text'], syntaxListener);
+		return this;
+	}
+
+	/**
+	 * @template {string} T
+	 * @param {T} key
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		if (key === 'pattern') {
+			return this.#pattern;
+		}
+		return super.getAttribute(key);
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return [];
+	}
+
+	/**
+	 * @param {...string|Token} elements
+	 * @complexity `n`
+	 */
+	replaceChildren(...elements) {
+		if (this.#pattern.test(text(elements))) {
+			Parser.run(() => {
+				super.replaceChildren(...elements);
+			});
+		}
+	}
+}
+
+Parser.classes.SyntaxToken = __filename;
+module.exports = SyntaxToken;