wikiparser-node 0.3.1 → 0.5.0

package/tool/index.js

@@ -1,7 +1,9 @@
+/* eslint no-underscore-dangle: [2, {allowAfterThis: true, enforceInMethodNames: false, allow: ['__filename']}] */
 'use strict';
 
 const {typeError, externalUse} = require('../util/debug'),
 	{text, noWrap} = require('../util/string'),
+	AstText = require('../lib/text'),
 	Token = require('../src'),
 	assert = require('assert/strict');
 
@@ -9,7 +11,7 @@ const /** @type {WeakMap<Token, Record<string, any>>} */ dataStore = new WeakMap
 
 /**
  * @param {string} method
- * @param {string|Token|Token[]} selector
+ * @param {AstText|Token|Token[]} selector
  * @returns {(token: Token) => boolean}
  */
 const matchesGenerator = (method, selector) => {
@@ -20,7 +22,7 @@ const matchesGenerator = (method, selector) => {
 	} else if (selector instanceof Token) {
 		return token => token === selector;
 	}
-	typeError(TokenCollection, method, 'String', 'Token', 'Array');
+	return typeError(TokenCollection, method, 'String', 'Token', 'Array'); // eslint-disable-line no-use-before-define
 };
 
 /** @extends {Array<Token>} */
@@ -37,10 +39,10 @@ class TokenCollection extends Array {
 		for (const token of arr) {
 			if (token === undefined) {
 				continue;
-			} else if (typeof token === 'string') {
+			} else if (token instanceof AstText) {
 				this.push(token);
 			} else if (!(token instanceof Token)) {
-				this.typeError('constructor', 'String', 'Token');
+				this.typeError('constructor', 'AstText', 'Token');
 			} else if (!this.includes(token)) {
 				this.#roots.add(token.getRootNode());
 				this.push(token);
@@ -58,20 +60,21 @@ class TokenCollection extends Array {
 		return typeError(this.constructor, method, ...types);
 	}
 
+	/** 节点排序 */
 	#sort() {
-		if (this.some(token => typeof token === 'string')) {
+		if (this.some(({type}) => type === 'text')) {
 			return;
 		}
 		const rootArray = [...this.#roots];
 		this.sort((a, b) => {
 			const aRoot = a.getRootNode(),
 				bRoot = b.getRootNode();
-			return aRoot === bRoot ? a.comparePosition(b) : rootArray.indexOf(aRoot) - rootArray.indexOf(bRoot);
+			return aRoot === bRoot ? a.compareDocumentPosition(b) : rootArray.indexOf(aRoot) - rootArray.indexOf(bRoot);
 		});
 	}
 
 	toArray() {
-		return Array.from(this);
+		return [...this];
 	}
 
 	_filter(selector = '') {
@@ -108,9 +111,9 @@ class TokenCollection extends Array {
 
 	/** @param {CollectionCallback<void, string|Token>} callback */
 	each(callback) {
-		this.forEach((ele, i) => { // 不能使用`for`...`of`
-			callback.call(ele, i, ele);
-		});
+		for (let i = 0; i < this.length; i++) {
+			callback.call(this[i], i, this[i]);
+		}
 		return this;
 	}
 
@@ -162,8 +165,9 @@ class TokenCollection extends Array {
 	text(str) {
 		/** @type {(ele: Token, i: number, str: string) => string} */
 		const callback = typeof str === 'function' ? str.call : () => str;
-		if (['string', 'function'].includes(typeof str)) {
-			for (const [i, ele] of this.entries()) {
+		if (typeof str === 'string' || typeof str === 'function') {
+			for (let i = 0; i < this.length; i++) {
+				const ele = this[i];
 				if (ele instanceof Token) {
 					try {
 						ele.replaceChildren(callback(ele, i, ele.text()));
@@ -237,7 +241,7 @@ class TokenCollection extends Array {
 		} else if (selector instanceof Token) {
 			return arr.some(ele => ele.contains(selector));
 		}
-		this.typeError('has', 'String', 'Token');
+		return this.typeError('has', 'String', 'Token');
 	}
 
 	/** @param {string} selector */
@@ -292,11 +296,11 @@ class TokenCollection extends Array {
 	 */
 	_siblings(start, count, selector = '') {
 		return this._create(arr => arr.flatMap(ele => {
-			const {parentElement} = ele;
-			if (!parentElement) {
+			const {parentNode} = ele;
+			if (!parentNode) {
 				return undefined;
 			}
-			const {children} = parentElement,
+			const {children} = parentNode,
 				i = children.indexOf(ele);
 			children.splice(
 				typeof start === 'function' ? start(i) : start,
@@ -323,7 +327,7 @@ class TokenCollection extends Array {
 	 * @param {string|Token|Token[]} selector
 	 */
 	_until(method, selector, filter = '') {
-		const matches = matchesGenerator(`${method.replace(/All$/, '')}Until`, selector);
+		const matches = matchesGenerator(`${method.replace(/All$/u, '')}Until`, selector);
 		return this._create(arr => arr.flatMap(ele => {
 			const tokens = $(ele)[method]().toArray(),
 				tokenArray = method === 'nextAll' ? tokens : tokens.reverse(),
@@ -382,7 +386,7 @@ class TokenCollection extends Array {
 		if (name !== undefined && typeof name !== 'string' && !Array.isArray(name)) {
 			this.typeError('removeData', 'String', 'Array');
 		}
-		name = typeof name === 'string' ? name.split(/\s/) : name;
+		name = typeof name === 'string' ? name.split(/\s/u) : name;
 		for (const token of this._filter()) {
 			if (!$.dataStore.has(token)) {
 				continue;
@@ -404,14 +408,14 @@ class TokenCollection extends Array {
 	 * @param {AstListener} handler
 	 */
 	_addEventListener(events, selector, handler, once = false) {
-		if (!['string', 'object'].includes(typeof events)) {
+		if (typeof events !== 'string' && typeof events !== 'object') {
 			this.typeError(once ? 'once' : 'on', 'String', 'Object');
 		} else if (typeof selector === 'function') {
 			handler = selector;
 			selector = undefined;
 		}
 		const eventPair = typeof events === 'string'
-			? events.split(/\s/).map(/** @returns {[string, AstListener]} */ event => [event, handler])
+			? events.split(/\s/u).map(/** @returns {[string, AstListener]} */ event => [event, handler])
 			: Object.entries(events);
 		for (const token of this._filter(selector)) {
 			for (const [event, listener] of eventPair) {
@@ -445,14 +449,14 @@ class TokenCollection extends Array {
 	 * @param {AstListener} handler
 	 */
 	off(events, selector, handler) {
-		if (!['string', 'object', 'undefined'].includes(typeof events)) {
+		if (typeof events !== 'string' && typeof events !== 'object' && events !== undefined) {
 			this.typeError('off', 'String', 'Object');
 		}
 		handler = typeof selector === 'function' ? selector : handler;
 		let eventPair;
 		if (events) {
 			eventPair = typeof events === 'string'
-				? events.split(/\s/).map(/** @returns {[string, AstListener]} */ event => [event, handler])
+				? events.split(/\s/u).map(/** @returns {[string, AstListener]} */ event => [event, handler])
 				: Object.entries(events);
 		}
 		for (const token of this._filter(selector)) {
@@ -460,7 +464,7 @@ class TokenCollection extends Array {
 				token.removeAllEventListeners();
 			} else {
 				for (const [event, listener] of eventPair) {
-					if (typeof event !== 'string' || !['function', 'undefined'].includes(typeof listener)) {
+					if (typeof event !== 'string' || typeof listener !== 'function' && listener !== undefined) {
 						this.typeError('off', 'String', 'Function');
 					} else if (listener) {
 						token.removeEventListener(event, listener);
@@ -486,7 +490,7 @@ class TokenCollection extends Array {
 	triggerHandler(event, data) {
 		const firstToken = this._find();
 		if (!firstToken) {
-			return;
+			return undefined;
 		}
 		const e = typeof event === 'string' ? new Event(event) : event,
 			listeners = firstToken.listEventListeners(typeof event === 'string' ? event : event.type);
@@ -504,7 +508,8 @@ class TokenCollection extends Array {
 	 */
 	_insert(method, content, ...additional) {
 		if (typeof content === 'function') {
-			for (const [i, token] of this.entries()) {
+			for (let i = 0; i < this.length; i++) {
+				const token = this[i];
 				if (token instanceof Token) {
 					const result = content.call(token, i, token.toString());
 					if (typeof result === 'string' || result instanceof Token) {
@@ -576,7 +581,8 @@ class TokenCollection extends Array {
 	}
 
 	remove(selector = '') {
-		for (const token of this.removeData()._filter(selector)) {
+		this.removeData();
+		for (const token of this._filter(selector)) {
 			token.remove();
 			token.removeAllEventListeners();
 		}
@@ -659,7 +665,8 @@ class TokenCollection extends Array {
 		} else {
 			this.typeError('val', 'String', 'Array', 'Function');
 		}
-		for (const [i, token] of this.entries()) {
+		for (let i = 0; i < this.length; i++) {
+			const token = this[i];
 			if (token instanceof Token && typeof token.setValue === 'function' && token.setValue.length === 1) {
 				token.setValue(toValue(i, token));
 			}
@@ -678,7 +685,8 @@ class TokenCollection extends Array {
 			const firstToken = this._find();
 			return firstToken?.[getter] && firstToken[getter](name);
 		}
-		for (const [i, token] of this.entries()) {
+		for (let i = 0; i < this.length; i++) {
+			const token = this[i];
 			if (token instanceof Token && typeof token[setter] === 'function') {
 				if (typeof value === 'string') {
 					token[setter](name, value);
@@ -784,6 +792,7 @@ class TokenCollection extends Array {
 			this.typeError(method, 'Array', 'Function');
 		}
 		return this[method](
+
 			/**
 			 * @this {string|Token}
 			 * @param {number} i
@@ -817,7 +826,7 @@ class TokenCollection extends Array {
 	offset() {
 		const firstToken = this._find();
 		if (!firstToken) {
-			return;
+			return undefined;
 		}
 		const {top, left} = firstToken.getBoundingClientRect();
 		return {top, left};
@@ -837,20 +846,21 @@ class TokenCollection extends Array {
 	}
 }
 
-/** @param {string|Token|Iterable<string|Token>} tokens */
+/** @param {AstText|Token|Iterable<string|Token>} tokens */
 const $ = tokens => {
-	if (typeof tokens === 'string' || tokens instanceof Token) {
+	if (tokens instanceof AstText || tokens instanceof Token) {
 		tokens = [tokens];
 	}
 	return new Proxy(new TokenCollection(...tokens), {
 		/** @param {PropertyKey} prop */
 		get(obj, prop) {
 			if (prop === Symbol.iterator || typeof obj[prop] !== 'function'
-				|| !prop.startsWith('_') && Object.getOwnPropertyDescriptor(obj.constructor.prototype, prop)
+				|| prop[0] !== '_' && Object.getOwnPropertyDescriptor(obj.constructor.prototype, prop)
 				|| !externalUse(prop, true)
 			) {
 				return obj[prop];
 			}
+			return undefined;
 		},
 		set(obj, prop, val) {
 			if (prop === 'prevObject' && (val === undefined || val instanceof TokenCollection)) {

package/util/debug.js

@@ -1,9 +1,11 @@
 'use strict';
 
 /**
- * @param {function}
- * @param {string} method
- * @param {...string} args
+ * 定制TypeError消息
+ * @param {Function} constructor 类
+ * @param {string} method 方法名称
+ * @param {...string} args 可接受的参数类型
+ * @throws `TypeError`
  */
 const typeError = ({name}, method, ...args) => {
 	throw new TypeError(`${name}.${method} 方法仅接受 ${args.join('、')} 作为输入参数！`);
@@ -11,28 +13,30 @@ const typeError = ({name}, method, ...args) => {
 
 /**
  * 不是被构造器或原型方法调用
- * @param {string} name
+ * @param {string} name 方法名称
  */
-const externalUse = (name, proxy = false) => {
-	if (!proxy && require('..').running) {
+const externalUse = name => {
+	const Parser = require('..');
+	if (Parser.running) {
 		return false;
 	}
-	const regex = RegExp(`^${
-		proxy ? 'Proxy' : 'new \\w*Token$|^(?:AstNode|AstElement|\\w*Token)'
-	}\\.(?!${name}$)`);
+	const regex = new RegExp(`^new \\w*Token$|^(?:Ast\\w*|\\w*Token)\\.(?!${name}$)`, 'u');
 	try {
-		throw new Error();
+		throw new Error(); // eslint-disable-line unicorn/error-message
 	} catch (e) {
 		if (e instanceof Error) {
-			const mt = e.stack.match(/(?<=^\s+at )(?:new )?[\w.]+(?= \(\/)/gm);
+			const mt = e.stack.match(/(?<=^\s+at )(?:new )?[\w.]+(?= \(\/)/gmu);
 			return !mt.slice(2).some(func => regex.test(func));
 		}
 	}
+	return false;
 };
 
 /**
- * @param {AstEvent} e
- * @param {AstEventData} data
+ * 撤销最近一次Mutation
+ * @param {AstEvent} e 事件
+ * @param {AstEventData} data 事件数据
+ * @throws `RangeError` 无法撤销的事件类型
  */
 const undo = (e, data) => {
 	const {target, type} = e;
@@ -40,6 +44,7 @@ const undo = (e, data) => {
 		case 'remove': {
 			const childNodes = [...target.childNodes];
 			childNodes.splice(data.position, 0, data.removed);
+			data.removed.setAttribute('parentNode', target);
 			target.setAttribute('childNodes', childNodes);
 			break;
 		}
@@ -53,15 +58,13 @@ const undo = (e, data) => {
 			const {parentNode} = target,
 				childNodes = [...parentNode.childNodes];
 			childNodes.splice(data.position, 1, data.oldToken);
+			data.oldToken.setAttribute('parentNode', parentNode);
 			parentNode.setAttribute('childNodes', childNodes);
 			break;
 		}
-		case 'text': {
-			const childNodes = [...target.childNodes];
-			childNodes[data.position] = data.oldText;
-			target.setAttribute('childNodes', childNodes);
+		case 'text':
+			target.replaceData(data.oldText);
 			break;
-		}
 		default:
 			throw new RangeError(`无法撤销未知类型的事件：${type}`);
 	}

package/util/diff.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const {spawn} = require('child_process'),
+	fs = require('fs/promises');
+
+process.on('unhandledRejection', e => {
+	console.error(e);
+});
+
+/**
+ * 将shell命令转化为Promise对象
+ * @param {string} command shell指令
+ * @param {string[]} args shell输入参数
+ * @returns {Promise<?string>}
+ */
+const cmd = (command, args) => new Promise(resolve => {
+	let timer, shell;
+
+	/**
+	 * 清除进程并返回
+	 * @param {any} val 返回值
+	 */
+	const r = val => {
+		clearTimeout(timer);
+		shell.kill('SIGINT');
+		resolve(val);
+	};
+	try {
+		shell = spawn(command, args);
+		timer = setTimeout(() => {
+			shell.kill('SIGINT');
+		}, 60 * 1000);
+		let buf = '';
+		shell.stdout.on('data', data => {
+			buf += data.toString();
+		});
+		shell.stdout.on('end', () => {
+			r(buf);
+		});
+		shell.on('exit', () => {
+			r(shell.killed ? null : '');
+		});
+		shell.on('error', () => {
+			r(null);
+		});
+	} catch {
+		r(null);
+	}
+});
+
+/**
+ * 比较两个文件
+ * @param {string} oldStr 旧文本
+ * @param {string} newStr 新文本
+ * @param {string} uid 唯一标识
+ */
+const diff = async (oldStr, newStr, uid = '') => {
+	if (oldStr === newStr) {
+		return;
+	}
+	const oldFile = `diffOld${uid}`,
+		newFile = `diffNew${uid}`;
+	await Promise.all([fs.writeFile(oldFile, oldStr), fs.writeFile(newFile, newStr)]);
+	const stdout = await cmd('git', [
+		'diff',
+		'--color-words=[\xC0-\xFF][\x80-\xBF]+|<?/?\\w+/?>?|[^[:space:]]',
+		'-U0',
+		'--no-index',
+		oldFile,
+		newFile,
+	]);
+	await Promise.all([fs.unlink(oldFile), fs.unlink(newFile)]);
+	console.log(stdout?.split('\n')?.slice(4)?.join('\n'));
+};
+
+module.exports = diff;

package/util/lint.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const Token = require('../src');
+
+/**
+ * 生成对于子节点的LintError对象
+ * @param {Token} child 子节点
+ * @param {{top: number, left: number}} boundingRect 父节点的绝对定位
+ * @param {string} message 错误信息
+ * @param {'error'|'warning'} severity 严重程度
+ * @returns {LintError}
+ */
+const generateForChild = (child, boundingRect, message, severity = 'error') => {
+	const {style: {top: offsetTop, left: offsetLeft, height, width}} = child,
+		{top, left} = boundingRect,
+		startLine = top + offsetTop,
+		endLine = startLine + height - 1,
+		startCol = offsetTop ? offsetLeft : left + offsetLeft,
+		endCol = height > 1 ? width : startCol + width;
+	return {message, severity, startLine, endLine, startCol, endCol};
+};
+
+/**
+ * 生成对于自己的LintError对象
+ * @param {Token} token 节点
+ * @param {{top: number, left: number}} boundingRect 绝对定位
+ * @param {string} message 错误信息
+ * @param {'error'|'warning'} severity 严重程度
+ * @returns {LintError}
+ */
+const generateForSelf = (token, boundingRect, message, severity = 'error') => ({
+	message,
+	severity,
+	startLine: boundingRect.top,
+	endLine: boundingRect.top + token.offsetHeight - 1,
+	startCol: boundingRect.left,
+	endCol: token.offsetHeight > 1 ? token.offsetWidth : boundingRect.left + token.offsetWidth,
+});
+
+module.exports = {generateForChild, generateForSelf};

package/util/string.js

@@ -2,40 +2,62 @@
 
 /**
  * optionally convert to lower cases
- * @param {string} val
- * @param {string|undefined} i
+ * @param {string} val 属性值
+ * @param {string|undefined} i 是否对大小写不敏感
  */
 const toCase = (val, i) => i ? val.toLowerCase() : val;
 
 /**
  * remove half-parsed comment-like tokens
- * @param {string} str
+ * @param {string} str 原字符串
  */
-const removeComment = str => str.replace(/\0\d+c\x7f/g, '');
+const removeComment = str => str.replaceAll(/\0\d+c\x7F/gu, '');
 
-/** @param {string} str */
-const ucfirst = str => str && `${str[0].toUpperCase()}${str.slice(1)}`;
+/**
+ * 以HTML格式打印
+ * @param {(AstText|AstElement)[]} childNodes 子节点
+ * @param {printOpt} opt 选项
+ */
+const print = (childNodes, opt = {}) => {
+	const AstText = require('../lib/text'),
+		AstElement = require('../lib/element');
+	const {pre = '', post = '', sep = ''} = opt,
+		entities = {'&': 'amp', '<': 'lt', '>': 'gt'};
+	return `${pre}${childNodes.map(
+		child => child instanceof AstElement
+			? child.print()
+			: String(child).replaceAll(/[&<>]/gu, p => `&${entities[p]};`),
+	).join(sep)}${post}`;
+};
 
-/** @param {string} str */
-const escapeRegExp = str => str.replace(/[\\{}()|.?*+\-^$[\]]/g, '\\$&');
+/**
+ * escape special chars for RegExp constructor
+ * @param {string} str RegExp source
+ */
+const escapeRegExp = str => str.replaceAll(/[\\{}()|.?*+^$[\]]/gu, '\\$&');
 
-/** @param {(string|AstNode)[]} childNodes */
+/**
+ * extract effective wikitext
+ * @param {(string|AstNode)[]} childNodes a Token's contents
+ * @param {string} separator delimiter between nodes
+ */
 const text = (childNodes, separator = '') => {
 	const AstNode = require('../lib/node');
 	return childNodes.map(child => typeof child === 'string' ? child : child.text()).join(separator);
 };
 
 /**
- * @param {string} start
- * @param {string} end
- * @param {string} separator
- * @param {string} str
+ * a more sophisticated string-explode function
+ * @param {string} start start syntax of a nested AST node
+ * @param {string} end end syntax of a nested AST node
+ * @param {string} separator syntax for explosion
+ * @param {string} str string to be exploded
  */
 const explode = (start, end, separator, str) => {
 	if (str === undefined) {
 		return [];
 	}
-	const regex = RegExp(`${[start, end, separator].map(escapeRegExp).join('|')}`, 'g'),
+	const regex = new RegExp(`${[start, end, separator].map(escapeRegExp).join('|')}`, 'gu'),
 		/** @type {string[]} */ exploded = [];
 	let mt = regex.exec(str),
 		depth = 0,
@@ -54,22 +76,30 @@ const explode = (start, end, separator, str) => {
 	return exploded;
 };
 
-/** @param {string} str */
+/**
+ * escape newlines
+ * @param {string} str 原字符串
+ */
 const noWrap = str => str.replaceAll('\n', '\\n');
 
 /**
- * @param {string|Token} token
- * @returns {string}
+ * convert newline in text nodes to single whitespace
+ * @param {Token & {childNodes: AstText[]}} token 父节点
  */
-const normalizeSpace = (token = '', separator = '') => {
-	const Token = require('../src');
-	return typeof token === 'string'
-		? token.replaceAll('\n', ' ')
-		: token.childNodes.map(child => typeof child === 'string' ? normalizeSpace(child) : child.toString())
-			.join(separator);
+const normalizeSpace = token => {
+	if (token === undefined) {
+		return;
+	}
+	const Token = require('../src'),
+		AstText = require('../lib/text');
+	for (const child of token.childNodes) {
+		if (child.type === 'text') {
+			child.replaceData(child.data.replaceAll('\n', ' '));
+		}
+	}
 };
 
-const extUrlChar = '(?:\\[[\\da-f:.]+\\]|[^[\\]<>"\\0-\\x1f\\x7f\\p{Zs}\\ufffd])'
-	+ '(?:[^[\\]<>"\\0-\\x1f\\x7f\\p{Zs}\\ufffd]|\\0\\d+c\\x7f)*';
+const extUrlChar = '(?:\\[[\\da-f:.]+\\]|[^[\\]<>"\\0-\\x1F\\x7F\\p{Zs}\\uFFFD])'
+	+ '(?:[^[\\]<>"\\0-\\x1F\\x7F\\p{Zs}\\uFFFD]|\\0\\d+c\\x7F)*';
 
-module.exports = {toCase, removeComment, ucfirst, escapeRegExp, text, explode, noWrap, normalizeSpace, extUrlChar};
+module.exports = {toCase, removeComment, print, escapeRegExp, text, explode, noWrap, normalizeSpace, extUrlChar};