wikiparser-node 0.3.1 → 0.5.0

package/src/attribute.js

@@ -1,19 +1,88 @@
 'use strict';
 
 const {externalUse} = require('../util/debug'),
+	{generateForSelf} = require('../util/lint'),
 	{toCase, removeComment, normalizeSpace} = require('../util/string'),
-	/** @type {Parser} */ Parser = require('..'),
+	Parser = require('..'),
 	Token = require('.');
 
 const stages = {'ext-attr': 0, 'html-attr': 2, 'table-attr': 3};
 
 /**
  * 扩展和HTML标签属性
- * @classdesc `{childNodes: [string]|(string|ArgToken|TranscludeToken)[]}`
+ * @classdesc `{childNodes: [AstText]|(AstText|ArgToken|TranscludeToken)[]}`
  */
 class AttributeToken extends Token {
 	/** @type {Map<string, string|true>} */ #attr = new Map();
 	#sanitized = true;
+	#quoteBalance = true;
+
+	/**
+	 * @override
+	 * @param {string} key 属性键
+	 * @param {string|undefined} equal 属性规则运算符，`equal`存在时`val`和`i`也一定存在
+	 * @param {string|undefined} val 属性值
+	 * @param {string|undefined} i 是否对大小写不敏感
+	 */
+	#matchesAttr = (key, equal, val, i) => {
+		if (!equal) {
+			return this.hasAttr(key);
+		} else if (!this.hasAttr(key)) {
+			return equal === '!=';
+		}
+		val = toCase(val, i);
+		const attr = this.getAttr(key),
+			thisVal = toCase(attr === true ? '' : attr, i);
+		switch (equal) {
+			case '~=':
+				return attr !== true && thisVal.split(/\s/u).includes(val);
+			case '|=': // 允许`val === ''`
+				return thisVal === val || thisVal.startsWith(`${val}-`);
+			case '^=':
+				return attr !== true && thisVal.startsWith(val);
+			case '$=':
+				return attr !== true && thisVal.endsWith(val);
+			case '*=':
+				return attr !== true && thisVal.includes(val);
+			case '!=':
+				return thisVal !== val;
+			default: // `=`
+				return thisVal === val;
+		}
+	};
+
+	/**
+	 * getAttr()方法的getter写法
+	 * @returns {Record<string, string|true>}
+	 */
+	get attributes() {
+		return this.getAttr();
+	}
+
+	/** 以字符串表示的class属性 */
+	get className() {
+		const attr = this.getAttr('class');
+		return typeof attr === 'string' ? attr : '';
+	}
+
+	set className(className) {
+		this.setAttr('class', className);
+	}
+
+	/** 以Set表示的class属性 */
+	get classList() {
+		return new Set(this.className.split(/\s/u));
+	}
+
+	/** id属性 */
+	get id() {
+		const attr = this.getAttr('id');
+		return typeof attr === 'string' ? attr : '';
+	}
+
+	set id(id) {
+		this.setAttr('id', id);
+	}
 
 	/**
 	 * 从`this.#attr`更新`childNodes`
@@ -22,10 +91,9 @@ class AttributeToken extends Token {
 	#updateFromAttr() {
 		let equal = '=';
 		const ParameterToken = require('./parameter'),
-			parent = this.closest('ext, parameter');
-		if (parent instanceof ParameterToken && parent.anon
-			&& parent.parentNode?.matches('template, magic-word#invoke')
-		) {
+			TranscludeToken = require('./transclude');
+		const /** @type {ParameterToken & {parentNode: TranscludeToken}} */ parent = this.closest('ext, parameter');
+		if (parent instanceof ParameterToken && parent.anon && parent.parentNode?.isTemplate()) {
 			equal = '{{=}}';
 		}
 		return [...this.#attr].map(([k, v]) => {
@@ -37,7 +105,10 @@ class AttributeToken extends Token {
 		}).join(' ');
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 清理标签属性
+	 * @complexity `n`
+	 */
 	sanitize() {
 		if (!Parser.running && !this.#sanitized) {
 			Parser.warn(`${this.constructor.name}.sanitize 方法将清理无效属性！`);
@@ -47,6 +118,7 @@ class AttributeToken extends Token {
 			this.replaceChildren(...token.childNodes, true);
 		});
 		this.#sanitized = true;
+		this.#quoteBalance = true;
 	}
 
 	/**
@@ -55,30 +127,42 @@ class AttributeToken extends Token {
 	 */
 	#parseAttr() {
 		this.#attr.clear();
-		let string = this.toString(),
-			/** @type {Token & {firstChild: string}} */ token;
+		let string = this.toString('comment, include, noinclude, heading, html'),
+			token;
 		if (this.type !== 'ext-attr' && !Parser.running) {
 			const config = this.getAttribute('config'),
 				include = this.getAttribute('include');
-			token = Parser.run(() => new Token(string, config).parseOnce(0, include).parseOnce());
-			string = token.firstChild;
+			token = Parser.run(() => {
+				const newToken = new Token(string, config),
+					parseOnce = newToken.getAttribute('parseOnce');
+				parseOnce(0, include);
+				return parseOnce();
+			});
+			string = String(token);
 		}
-		string = removeComment(string).replace(/\0\d+~\x7f/g, '=');
-		const build = /** @param {string|boolean} str */ str =>
-			typeof str === 'boolean' || !token ? str : token.buildFromStr(str).map(String).join('');
-		for (const [, key,, quoted, unquoted] of string
-			.matchAll(/([^\s/][^\s/=]*)(?:\s*=\s*(?:(["'])(.*?)(?:\2|$)|(\S*)))?/gs)
+		string = removeComment(string).replaceAll(/\0\d+~\x7F/gu, '=');
+
+		/**
+		 * 解析并重建标签属性
+		 * @param {string|boolean} str 半解析的标签属性文本
+		 */
+		const build = str =>
+			typeof str === 'boolean' || !token ? str : token.getAttribute('buildFromStr')(str).map(String).join('');
+		for (const [, key, quoteStart, quoted, quoteEnd, unquoted] of string
+			.matchAll(/([^\s/][^\s/=]*)(?:\s*=\s*(?:(["'])(.*?)(\2|$)|(\S*)))?/gsu)
 		) {
 			if (!this.setAttr(build(key), build(quoted ?? unquoted ?? true), true)) {
 				this.#sanitized = false;
+			} else if (quoteStart !== quoteEnd) {
+				this.#quoteBalance = false;
 			}
 		}
 	}
 
 	/**
-	 * @param {string} attr
-	 * @param {'ext-attr'|'html-attr'|'table-attr'} type
-	 * @param {string} name
+	 * @param {string} attr 标签属性
+	 * @param {'ext-attr'|'html-attr'|'table-attr'} type 标签类型
+	 * @param {string} name 标签名
 	 * @param {accum} accum
 	 */
 	constructor(attr, type, name, config = Parser.getConfig(), accum = []) {
@@ -87,8 +171,9 @@ class AttributeToken extends Token {
 		this.setAttribute('name', name).#parseAttr();
 	}
 
+	/** @override */
 	cloneNode() {
-		const cloned = this.cloneChildren();
+		const cloned = this.cloneChildNodes();
 		return Parser.run(() => {
 			const token = new AttributeToken(undefined, this.type, this.name, this.getAttribute('config'));
 			token.append(...cloned);
@@ -97,28 +182,31 @@ class AttributeToken extends Token {
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {TokenAttribute<T>}
 	 */
 	getAttribute(key) {
-		if (key === 'attr') {
-			return new Map(this.#attr);
+		if (key === 'matchesAttr') {
+			return this.#matchesAttr;
 		}
-		return super.getAttribute(key);
+		return key === 'attr' ? new Map(this.#attr) : super.getAttribute(key);
 	}
 
+	/** @override */
 	afterBuild() {
 		if (this.type !== 'ext-attr') {
+			const buildFromStr = this.getAttribute('buildFromStr');
 			for (let [key, text] of this.#attr) {
 				let built = false;
 				if (key.includes('\0')) {
 					this.#attr.delete(key);
-					key = this.buildFromStr(key).map(String).join('');
+					key = buildFromStr(key).map(String).join('');
 					built = true;
 				}
 				if (typeof text === 'string' && text.includes('\0')) {
-					text = this.buildFromStr(text).map(String).join('');
+					text = buildFromStr(text).map(String).join('');
 					built = true;
 				}
 				if (built) {
@@ -126,65 +214,74 @@ class AttributeToken extends Token {
 				}
 			}
 		}
-		const that = this,
-			/** @type {AstListener} */ attributeListener = ({type, target}) => {
-				if (type === 'text' || target !== that) {
-					that.#parseAttr();
-				}
-			};
+		const /** @type {AstListener} */ attributeListener = ({type, target}) => {
+			if (type === 'text' || target !== this) {
+				this.#parseAttr();
+			}
+		};
 		this.addEventListener(['remove', 'insert', 'replace', 'text'], attributeListener);
 		return this;
 	}
 
-	/** @param {string} key */
+	/**
+	 * 标签是否具有某属性
+	 * @param {string} key 属性键
+	 */
 	hasAttr(key) {
-		if (typeof key !== 'string') {
-			this.typeError('hasAttr', 'String');
-		}
-		return this.#attr.has(key.toLowerCase().trim());
+		return typeof key === 'string' ? this.#attr.has(key.toLowerCase().trim()) : this.typeError('hasAttr', 'String');
 	}
 
 	/**
+	 * 获取标签属性
 	 * @template {string|undefined} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {T extends string ? string|true : Record<string, string|true>}
 	 */
 	getAttr(key) {
 		if (key === undefined) {
 			return Object.fromEntries(this.#attr);
-		} else if (typeof key !== 'string') {
-			this.typeError('getAttr', 'String');
 		}
-		return this.#attr.get(key.toLowerCase().trim());
+		return typeof key === 'string' ? this.#attr.get(key.toLowerCase().trim()) : this.typeError('getAttr', 'String');
 	}
 
+	/** 获取全部的标签属性名 */
 	getAttrNames() {
 		return [...this.#attr.keys()];
 	}
 
+	/** 标签是否具有任意属性 */
 	hasAttrs() {
 		return this.getAttrNames().length > 0;
 	}
 
 	/**
-	 * @param {string} key
-	 * @param {string|boolean} value
+	 * 设置标签属性
+	 * @param {string} key 属性键
+	 * @param {string|boolean} value 属性值
+	 * @param {boolean} init 是否是初次解析
 	 * @complexity `n`
+	 * @throws `RangeError` 扩展标签属性不能包含">"
+	 * @throws `RangeError` 无效的属性名
 	 */
-	setAttr(key, value, init = false) {
+	setAttr(key, value, init) {
 		init &&= !externalUse('setAttr');
-		if (typeof key !== 'string' || !['string', 'boolean'].includes(typeof value)) {
-			this.typeError('setValue', 'String', 'Boolean');
+		if (typeof key !== 'string' || typeof value !== 'string' && typeof value !== 'boolean') {
+			this.typeError('setAttr', 'String', 'Boolean');
 		} else if (!init && this.type === 'ext-attr' && typeof value === 'string' && value.includes('>')) {
 			throw new RangeError('扩展标签属性不能包含 ">"！');
 		}
 		key = key.toLowerCase().trim();
 		const config = this.getAttribute('config'),
 			include = this.getAttribute('include'),
-			parsedKey = this.type !== 'ext-attr' && !init
-				? Parser.run(() => new Token(key, config).parseOnce(0, include).parseOnce().firstChild)
-				: key;
-		if (!/^(?:[\w:]|\0\d+[t!~{}+-]\x7f)(?:[\w:.-]|\0\d+[t!~{}+-]\x7f)*$/.test(parsedKey)) {
+			parsedKey = this.type === 'ext-attr' || init
+				? key
+				: Parser.run(() => {
+					const token = new Token(key, config),
+						parseOnce = token.getAttribute('parseOnce');
+					parseOnce(0, include);
+					return String(parseOnce());
+				});
+		if (!/^(?:[\w:]|\0\d+[t!~{}+-]\x7F)(?:[\w:.-]|\0\d+[t!~{}+-]\x7F)*$/u.test(parsedKey)) {
 			if (init) {
 				return false;
 			}
@@ -192,7 +289,7 @@ class AttributeToken extends Token {
 		} else if (value === false) {
 			this.#attr.delete(key);
 		} else {
-			this.#attr.set(key, value === true ? true : value.replace(/\s/g, ' ').trim());
+			this.#attr.set(key, value === true ? true : value.replaceAll(/\s/gu, ' ').trim());
 		}
 		if (!init) {
 			this.sanitize();
@@ -201,7 +298,8 @@ class AttributeToken extends Token {
 	}
 
 	/**
-	 * @param {string} key
+	 * 移除标签属性
+	 * @param {string} key 属性键
 	 * @complexity `n`
 	 */
 	removeAttr(key) {
@@ -215,9 +313,11 @@ class AttributeToken extends Token {
 	}
 
 	/**
-	 * @param {string} key
-	 * @param {boolean|undefined} force
+	 * 开关标签属性
+	 * @param {string} key 属性键
+	 * @param {boolean|undefined} force 强制开启或关闭
 	 * @complexity `n`
+	 * @throws `RangeError` 不为Boolean类型的属性值
 	 */
 	toggleAttr(key, force) {
 		if (typeof key !== 'string') {
@@ -233,31 +333,71 @@ class AttributeToken extends Token {
 		this.setAttr(key, force === true || force === undefined && value === false);
 	}
 
+	/**
+	 * 生成引导空格
+	 * @param {string} str 属性字符串
+	 */
 	#leadingSpace(str = super.toString()) {
-		return this.type !== 'table-attr' && str && !/^\s/.test(str) ? ' ' : '';
+		return this.type !== 'table-attr' && str && str.trimStart() === str ? ' ' : '';
 	}
 
-	/** @this {AttributeToken & Token} */
-	toString() {
-		const str = this.type === 'table-attr' ? normalizeSpace(this) : super.toString();
+	/**
+	 * @override
+	 * @this {AttributeToken & Token}
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		if (this.type === 'table-attr') {
+			normalizeSpace(this);
+		}
+		const str = super.toString(selector);
 		return `${this.#leadingSpace(str)}${str}`;
 	}
 
+	/** @override */
 	getPadding() {
 		return this.#leadingSpace().length;
 	}
 
+	/**
+	 * @override
+	 * @this {AttributeToken & {parentNode: HtmlToken}}
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const HtmlToken = require('./html');
+		const errors = super.lint(start);
+		let /** @type {{top: number, left: number}} */ rect;
+		if (this.type === 'html-attr' && this.parentNode.closing && this.text().trim()) {
+			rect = this.getRootNode().posFromIndex(start);
+			errors.push(generateForSelf(this, rect, '位于闭合标签的属性'));
+		}
+		if (!this.#sanitized) {
+			rect ||= this.getRootNode().posFromIndex(start);
+			errors.push(generateForSelf(this, rect, '包含无效属性'));
+		} else if (!this.#quoteBalance) {
+			rect ||= this.getRootNode().posFromIndex(start);
+			errors.push(generateForSelf(this, rect, '未闭合的引号', 'warning'));
+		}
+		return errors;
+	}
+
+	/** @override */
 	text() {
-		let str = this.#updateFromAttr();
-		str = `${this.#leadingSpace(str)}${str}`;
-		return this.type === 'table-attr' ? normalizeSpace(str) : str;
+		if (this.type === 'table-attr') {
+			normalizeSpace(this);
+		}
+		const str = this.#updateFromAttr();
+		return `${this.#leadingSpace(str)}${str}`;
 	}
 
 	/**
-	 * @param {number} i
+	 * @override
+	 * @param {number} i 移除位置
+	 * @param {boolean} done 是否已解析过改变后的标签属性
 	 * @complexity `n`
 	 */
-	removeAt(i, done = false) {
+	removeAt(i, done) {
 		done &&= !externalUse('removeAt');
 		done ||= Parser.running;
 		const token = super.removeAt(i);
@@ -268,8 +408,11 @@ class AttributeToken extends Token {
 	}
 
 	/**
-	 * @template {string|Token} T
-	 * @param {T} token
+	 * @override
+	 * @template {Token} T
+	 * @param {T} token 待插入的节点
+	 * @param {number} i 插入位置
+	 * @param {boolean} done 是否已解析过改变后的标签属性
 	 * @complexity `n`
 	 */
 	insertAt(token, i = this.childNodes.length, done = false) {
@@ -283,7 +426,8 @@ class AttributeToken extends Token {
 	}
 
 	/**
-	 * @param {...string|Token} elements
+	 * @override
+	 * @param {...Token} elements 待替换的子节点
 	 * @complexity `n²`
 	 */
 	replaceChildren(...elements) {
@@ -299,41 +443,6 @@ class AttributeToken extends Token {
 			this.insertAt(element, undefined, done);
 		}
 	}
-
-	/**
-	 * @param {string} key
-	 * @param {string|undefined} equal - `equal`存在时`val`和`i`也一定存在
-	 * @param {string|undefined} val
-	 * @param {string|undefined} i
-	 */
-	matchesAttr(key, equal, val, i) {
-		if (externalUse('matchesAttr')) {
-			throw new Error(`禁止外部调用 ${this.constructor.name}.matchesAttr 方法！`);
-		} else if (!equal) {
-			return this.hasAttr(key);
-		} else if (!this.hasAttr(key)) {
-			return equal === '!=';
-		}
-		val = toCase(val, i);
-		const attr = this.getAttr(key),
-			thisVal = toCase(attr === true ? '' : attr, i);
-		switch (equal) {
-			case '~=':
-				return attr !== true && thisVal.split(/\s/).some(v => v === val);
-			case '|=': // 允许`val === ''`
-				return thisVal === val || thisVal.startsWith(`${val}-`);
-			case '^=':
-				return attr !== true && thisVal.startsWith(val);
-			case '$=':
-				return attr !== true && thisVal.endsWith(val);
-			case '*=':
-				return attr !== true && thisVal.includes(val);
-			case '!=':
-				return thisVal !== val;
-			default: // `=`
-				return thisVal === val;
-		}
-	}
 }
 
 Parser.classes.AttributeToken = __filename;