wikiparser-node 0.3.0 → 0.4.0

package/typings/parser.d.ts

@@ -4,6 +4,13 @@ declare global {
 		findEqual: boolean;
 		pos: number;
 	}
+	interface SelectorArray extends Array<string|RegExpExecArray> {
+		relation: string|undefined;
+	}
+
+	type pseudo = 'root'|'is'|'not'|'nth-child'|'nth-of-type'|'nth-last-child'|'nth-last-of-type'
+		|'first-child'|'first-of-type'|'last-child'|'last-of-type'|'only-child'|'only-of-type'|'empty'
+		|'contains'|'has'|'header'|'parent'|'hidden'|'visible';
 }
 
 export {};

package/typings/tool.d.ts

@@ -1,10 +1,11 @@
 import Token from '../src';
+import AstText from '../lib/text';
 
 declare global {
 	interface CollectionCallback<T, S> extends Function {
-		call: (thisArg: string|Token, i: number, ele: S) => T;
+		call: (thisArg: AstText|Token, i: number, ele: S) => T;
 	}
-	type CollectionMap = (arr: Token[]) => (string|Token)[];
+	type CollectionMap = (arr: Token[]) => (AstText|Token)[];
 }
 
 export {};

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 = new 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/string.js

@@ -2,40 +2,45 @@
 
 /**
  * optionally convert to lower cases
- * @param {string} val
- * @param {boolean} 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(/\x00\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)}`;
-
-/** @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 = new 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 +59,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 = '(?:[\\d.]+|\\[[\\da-f:.]+\\]|[^[\\]<>"\\x00-\\x20\\x7f\\p{Zs}\\ufffd])'
-	+ '(?:[^[\\]<>"\\x00-\\x20\\x7f\\p{Zs}\\ufffd]|\\x00\\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, escapeRegExp, text, explode, noWrap, normalizeSpace, extUrlChar};

package/typings/element.d.ts

@@ -1,28 +0,0 @@
-import Token from '../src';
-
-declare global {
-	interface AstEvent extends Event {
-		readonly target: Token;
-		currentTarget: Token;
-		prevTarget: ?Token;
-	};
-	interface AstEventData {
-		position: number;
-		removed: string|Token;
-		inserted: string|Token;
-		oldToken: Token;
-		newToken: Token;
-		oldText: string;
-		newText: string;
-		oldKey: string;
-		newKey: string;
-	}
-	type AstListener = (e: AstEvent, data: AstEventData) => any;
-
-	type pseudo = 'root'|'is'|'not'|'nth-child'|'nth-of-type'|'nth-last-child'|'nth-last-of-type'
-		|'first-child'|'first-of-type'|'last-child'|'last-of-type'|'only-child'|'only-of-type'|'empty'
-		|'contains'|'has'|'header'|'parent'|'hidden'|'visible';
-	type pseudoCall = Record<pseudo, string[]>;
-}
-
-export {};