AstElement - bhsd-harry/wikiparser-node GitHub Wiki

目录

Other Languages

简介

AstElement 是非纯文本节点的父类，仿照 HTMLElement 类设计，属性和方法也和 HTMLElement 类非常相似。这个类继承了 AstNode 类的全部属性和方法，这里不再列出。

✅ 在 Mini 和 Browser 版本中可用。
🌐 在 Browser 版本中可用。

Properties

length

✅ 展开

type: number
子节点总数。

// length
assert.strictEqual(Parser.parse([[a]]b').length, 2);
// length (main)
var root = Parser.parse([[a]]b');
root.length = 1;
assert.equal(root, '[[a]]');

children

展开

type: Token[]
全部非文本子节点，只读。

// children (main)
var root = Parser.parse([[a]]b'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.children, [firstChild]);

firstElementChild

展开

type: Token
首位非文本子节点，只读。

// firstElementChild (main)
var root = Parser.parse('b[[a]]'),
	{lastChild} = root;
assert.equal(lastChild, '[[a]]');
assert.strictEqual(root.firstElementChild, lastChild);

lastElementChild

展开

type: Token
末位非文本子节点，只读。

// lastElementChild (main)
var root = Parser.parse([[a]]b'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.lastElementChild, firstChild);

childElementCount

展开

type: number
非文本子节点总数，只读。

// childElementCount (main)
assert.strictEqual(Parser.parse([[a]]b').childElementCount, 1);

parentElement

展开

type: Token
父节点，即 parentNode 属性的别名，只读。

// parentElement (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(firstChild.parentElement, root);
assert.strictEqual(root.parentElement, undefined);

outerText

展开

type: string
等效 text 方法的返回值，只读。

// outerText (main)
assert.strictEqual(
	Parser.parse('<!--a-->b{{c|__nocc__}}').outerText,
	'b{{c|}}',
);

hidden

展开

type: boolean
是否不可见，只读。

// hidden (main)
var {firstChild, lastChild} = Parser.parse('<!--a-->__nocc__');
assert.equal(firstChild, '<!--a-->');
assert.equal(lastChild, '__nocc__');
assert.ok(firstChild.hidden);
assert.ok(lastChild.hidden);

clientHeight

展开

type: number
内部高度，仅当内部文本 innerText 属性有定义时存在，只读。

// clientHeight (main)
var root = Parser.parse('<pre>a\nb</pre>'),
	{firstChild} = root;
assert.equal(firstChild, '<pre>a\nb</pre>');
assert.strictEqual(firstChild.innerText, 'a\nb');
assert.strictEqual(firstChild.clientHeight, 2);
assert.strictEqual(root.clientHeight, undefined);

clientWidth

展开

type: number
内部宽度，仅当内部文本 innerText 属性有定义时存在，只读。

// clientWidth (main)
var root = Parser.parse('<pre>ab\nc</pre>'),
	{firstChild} = root;
assert.equal(firstChild, '<pre>ab\nc</pre>');
assert.strictEqual(firstChild.innerText, 'ab\nc');
assert.strictEqual(firstChild.clientWidth, 1);
assert.strictEqual(root.clientWidth, undefined);

images

展开

type: Token[]
所有图片节点，只读。

// images (main)
var root = Parser.parse('[[file:a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[file:a]]');
assert.deepStrictEqual(root.images, [firstChild]);

links

展开

type: Token[]
所有内链、外链、自由外链和图片链接，只读。

// links (main)
var root = Parser.parse([[a]][//b]http://c[[file:d|link=e]]'),
	{childNodes: [link, extLink, magicLink, {lastChild}]} = root;
assert.equal(link, '[[a]]');
assert.equal(extLink, '[//b]');
assert.equal(magicLink, 'http://c');
assert.equal(lastChild, 'link=e');
assert.deepStrictEqual(root.links, [
	link,
	extLink,
	magicLink,
	lastChild,
]);

embeds

展开

type: Token[]
所有嵌入的模板和模块，只读。

// embeds (main)
var root = Parser.parse('{{a}}{{#invoke:b|c}}'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '{{a}}');
assert.equal(lastChild, '{{#invoke:b|c}}');
assert.deepStrictEqual(root.embeds, [firstChild, lastChild]);

Methods

text

✅ 展开

returns: string
可见部分，详见各类型节点的文档。

// text
assert.strictEqual(Parser.parse('<!--a-->b{{c|__nocc__}}').text(), 'b{{c|}}');

closest

✅ 展开

param: string 选择器
最近的祖先节点。

// closest
var root = Parser.parse('[[a]]'),
	{firstChild: link} = root,
	{firstChild} = link;
assert.equal(link, '[[a]]');
assert.strictEqual(firstChild.closest('root'), root);
assert.strictEqual(firstChild.closest('root, link'), link);
// closest (main)
var root = Parser.parse('[[a]]'),
	{firstChild: link} = root,
	{firstChild} = link;
assert.equal(link, '[[a]]');
assert.strictEqual(firstChild.closest('link#A'), link);
assert.strictEqual(firstChild.closest('root, link#B'), root);

querySelector

✅ 展开

param: string 选择器
returns: Token
符合选择器的第一个后代节点。

// querySelector
var root = Parser.parse('<p><i>'),
	{firstChild} = root;
assert.equal(firstChild, '<p>');
assert.strictEqual(root.querySelector('html'), firstChild);

querySelectorAll

✅ 展开

param: string 选择器
returns: Token[]
符合选择器的所有后代节点。

// querySelectorAll
var root = Parser.parse('<p><i>'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '<p>');
assert.equal(lastChild, '<i>');
assert.deepStrictEqual(root.querySelectorAll('html'), [
	firstChild,
	lastChild,
]);

caretPositionFromIndex

✅ 展开

param: number 字符位置
returns: {offsetNode: AstNode, offset: number}
找到给定位置。

// caretPositionFromIndex
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.caretPositionFromIndex(1), {
	offsetNode: firstChild,
	offset: 1,
});

elementFromIndex

✅ 展开

param: number 字符位置
returns: Token
找到给定位置所在的最外层节点。

// elementFromIndex
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.elementFromIndex(1), firstChild);

elementFromPoint

✅ 展开

param: number 字符所在列
param: number 字符所在行
returns: Token
找到给定位置所在的最外层节点。

// elementFromPoint
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.elementFromPoint(1, 0), firstChild);

lint

✅ 展开

returns: LintError[]
报告潜在语法错误，详见各类型节点的文档。

print

🌐 展开

returns: string
以HTML格式输出，详见各类型节点的文档。

json

🌐 展开

param: string 文件名
将语法树保存为 JSON。保存的 JSON 文件都在 WikiParser-Node 的 printed/ 路径下。

// json
assert.deepStrictEqual(Parser.parse('<!-- a -->').json(), {
	range: [0, 10],
	type: 'root',
	childNodes: [
		{
			range: [0, 10],
			type: 'comment',
			closed: true,
			childNodes: [
				{
					range: [4, 7],
					data: ' a ',
				},
			],
		},
	],
});

removeAt

✅ 展开

param: number 移除位置
returns: AstNode
移除子节点。

// removeAt
var root = Parser.parse([[a]]b');
root.removeAt(1);
assert.equal(root, '[[a]]');

insertAt

✅ 展开

param: AstNode | string 待插入的子节点
param: number 插入位置
returns: AstNode
插入子节点。

// insertAt
var root = Parser.parse('a');
root.insertAt('b', 0);
assert.equal(root, 'ba');

append

✅ 展开

param: AstNode | string 插入节点
在末尾批量插入子节点。

// append
var root = Parser.parse('a');
root.append('b', 'c');
assert.equal(root, 'abc');

replaceChildren

✅ 展开

param: AstNode | string 新的子节点
批量替换子节点。

// replaceChildren
var root = Parser.parse('a[[b]]');
root.replaceChildren('c', 'd');
assert.equal(root, 'cd');

setText

✅ 展开

param: string 新文本
param: number 文本子节点位置
returns: string
修改文本子节点。

// setText
var root = Parser.parse([[a]]b');
root.setText('c', -1);
assert.equal(root, [[a]]c');

normalize

展开

合并相邻的文本子节点。

// normalize
var root = Parser.parse('[[a]]');
root.append('');
assert.strictEqual(root.length, 2);
root.normalize();
assert.strictEqual(root.length, 1);
// normalize (main)
var root = Parser.parse('a');
root.prepend('b');
assert.strictEqual(root.length, 2);
root.normalize();
assert.strictEqual(root.length, 1);

matches

展开

param: string 选择器
returns: boolean
检查是否符合选择器。

// matches (main)
var {firstChild} = Parser.parse('<br/>');
assert.ok(firstChild.matches('root > :is(#br[selfClosing])'));

getElementByTypes

展开

param: string 以,分隔的节点类型
returns: Token
类型选择器。

// getElementByTypes (main)
var root = Parser.parse([[a]]<i>'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.getElementByTypes('html, link'), firstChild);

getElementById

展开

param: string id 名
returns: Token
id 选择器。

// getElementById (main)
var root = Parser.parse('<p id=a>'),
	{firstChild} = root;
assert.equal(firstChild, '<p id=a>');
assert.strictEqual(root.getElementById('a'), firstChild);

getElementsByClassName

展开

param: string 类名之一
returns: Token[]
类选择器。

// getElementsByClassName (main)
var root = Parser.parse(`{|class="a b"
|}<p class="a c"><pre class="a d"></pre>`),
	{childNodes: [table, html, ext]} = root;
assert.equal(table, '{|class="a b"\n|}');
assert.equal(table.childNodes[1], 'class="a b"');
assert.equal(html, '<p class="a c">');
assert.equal(html.firstChild, ' class="a c"');
assert.equal(ext, '<pre class="a d"></pre>');
assert.equal(ext.firstChild, ' class="a d"');
assert.deepStrictEqual(root.getElementsByClassName('a'), [
	table,
	table.childNodes[1],
	html,
	html.firstChild,
	ext,
	ext.firstChild,
]);

getElementsByTagName

展开

param: string 标签名
returns: Token[]
标签名选择器。

// getElementsByTagName (main)
var root = Parser.parse('<i></i>'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '<i>');
assert.equal(lastChild, '</i>');
assert.deepStrictEqual(root.getElementsByTagName('i'), [
	firstChild,
	lastChild,
]);

caretPositionFromPoint

展开

param: number 字符所在列
param: number 字符所在行
returns: {offsetNode: AstNode, offset: number}
找到给定位置。

// caretPositionFromPoint (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.caretPositionFromPoint(1, 0), {
	offsetNode: firstChild,
	offset: 1,
});

elementsFromIndex

展开

param: number 字符位置
returns: Token[]
找到给定位置所在的所有节点。

// elementsFromIndex (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.elementsFromIndex(1), [root, firstChild]);

elementsFromPoint

展开

param: number 字符行
param: number 字符列
returns: Token[]
找到给定位置所在的所有节点。

// elementsFromPoint (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.elementsFromPoint(1, 0), [root, firstChild]);

prepend

展开

param: AstNode | string 插入节点
在开头批量插入子节点。

// prepend (main)
var root = Parser.parse('a');
root.prepend('b', 'c');
assert.equal(root, 'bca');

removeChild

展开

param: AstNode 子节点
移除子节点。

// removeChild (main)
var root = Parser.parse('a[[b]]');
root.removeChild(root.firstChild);
assert.equal(root, '[[b]]');

insertBefore

展开

param: AstNode 插入节点
param: AstNode 指定位置处的子节点
在指定位置前插入子节点。

// insertBefore (main)
var root = Parser.parse('a');
root.insertBefore('b', root.firstChild);
assert.equal(root, 'ba');

相关软件包

WikiLint

对维基文本批量执行语法检查的命令行工具

WikiParser Language Server

用于维基文本的 VSCode 扩展

Related Packages

WikiLint

A command-line tool that performs linting on Wikitext in bulk

WikiParser Language Server

VSCode extension for Wikitext

⚠️ **GitHub.com Fallback** ⚠️