AstNode

简介
Properties
Methods

Other Languages

English

简介

AstNode 是所有纯文本节点和其他节点的父类，仿照 Node 类设计，属性和方法也和 Node 类非常相似。

✅ 在 Mini 和 Browser 版本中可用。

Properties

childNodes

✅ 展开

type: AstNode[]
全部子节点构成的数组，只读。

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

firstChild

✅ 展开

type: AstNode
首位子节点，只读。

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

lastChild

✅ 展开

type: AstNode
末位子节点，只读。

// lastChild
var root = Parser.parse('a'),
	{lastChild} = root;
assert.equal(lastChild, 'a');
assert.strictEqual(lastChild.lastChild, undefined);

parentNode

✅ 展开

type: Token
父节点，只读。

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

nextSibling

✅ 展开

type: AstNode
后一个兄弟节点，只读。

// nextSibling
var {firstChild, lastChild} = Parser.parse([[a]]b');
assert.equal(firstChild, '[[a]]');
assert.equal(lastChild, 'b');
assert.strictEqual(firstChild.nextSibling, lastChild);
assert.strictEqual(lastChild.nextSibling, undefined);

previousSibling

✅ 展开

type: AstNode
前一个兄弟节点，只读。

// previousSibling
var {firstChild, lastChild} = Parser.parse([[a]]b');
assert.equal(firstChild, '[[a]]');
assert.equal(lastChild, 'b');
assert.strictEqual(lastChild.previousSibling, firstChild);
assert.strictEqual(firstChild.previousSibling, undefined);

offsetHeight

✅ 展开

type: number
行数，只读。

// offsetHeight
var root = Parser.parse('a\nb');
assert.strictEqual(root.offsetHeight, 2);

offsetWidth

✅ 展开

type: number
最后一行的列数，只读。

// offsetWidth
var root = Parser.parse('ab\nc');
assert.strictEqual(root.offsetWidth, 1);

nextElementSibling

展开

type: Token
后一个非文本兄弟节点，只读。

// nextElementSibling (main)
var {childNodes: [a, b, c]} = Parser.parse([[a]]b{{c}}');
assert.equal(a, '[[a]]');
assert.equal(b, 'b');
assert.equal(c, '{{c}}');
assert.strictEqual(a.nextElementSibling, c);
assert.strictEqual(b.nextElementSibling, c);
assert.strictEqual(c.nextElementSibling, undefined);

previousElementSibling

展开

type: Token
前一个非文本兄弟节点，只读。

// previousElementSibling (main)
var {childNodes: [a, b, c]} = Parser.parse([[a]]b{{c}}');
assert.equal(a, '[[a]]');
assert.equal(b, 'b');
assert.equal(c, '{{c}}');
assert.strictEqual(c.previousElementSibling, a);
assert.strictEqual(b.previousElementSibling, a);
assert.strictEqual(a.previousElementSibling, undefined);

nextVisibleSibling

展开

type: AstNode
后一个可见的兄弟节点，只读。

// nextVisibleSibling (main)
var {firstChild, lastChild} = Parser.parse([[a]]<!--b--><noinclude>c');
assert.equal(firstChild, '[[a]]');
assert.equal(lastChild, 'c');
assert.strictEqual(firstChild.nextVisibleSibling, lastChild);

previousVisibleSibling

展开

type: AstNode
前一个可见的兄弟节点，只读。

// previousVisibleSibling (main)
var {firstChild, lastChild} = Parser.parse('a<!--b--><noinclude>{{c}}');
assert.equal(firstChild, 'a');
assert.equal(lastChild, '{{c}}');
assert.strictEqual(lastChild.previousVisibleSibling, firstChild);

isConnected

展开

type: boolean
是否具有根节点，只读。

// isConnected (main)
var root = Parser.parse('a'),
	{firstChild} = root;
assert(root.isConnected);
assert(firstChild.isConnected);
firstChild.remove();
assert(!firstChild.isConnected);
root.append(firstChild);
assert(firstChild.isConnected);

eof

展开

type: boolean
后方是否还有其他节点（不含后代），只读。

// eof (main)
var root = Parser.parse('a[[b]]\n'),
	{firstChild, firstElementChild} = root,
	{lastChild} = firstElementChild;
assert.equal(firstChild, 'a');
assert.equal(firstElementChild, '[[b]]');
assert.equal(lastChild, 'b');
assert(root.eof);
assert(!firstChild.eof);
assert(firstElementChild.eof); // 忽略末尾的空白字符
assert(lastChild.eof);

offsetTop

展开

type: number
相对于父容器的行号（从 0 开始计数），只读。

// offsetTop (main)
var root = Parser.parse('a\n[[b]]'),
	{firstChild, lastChild} = root;
assert.equal(lastChild, '[[b]]');
assert.strictEqual(root.offsetTop, 0);
assert.strictEqual(firstChild.offsetTop, 0);
assert.strictEqual(lastChild.offsetTop, 1);

offsetLeft

展开

type: number
相对于父容器的列号（从 0 开始计数），只读。

// offsetLeft (main)
var root = Parser.parse([[a]]\nb'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.offsetLeft, 0);
assert.strictEqual(firstChild.offsetLeft, 0);
assert.strictEqual(lastChild.offsetLeft, 5);

style

展开

type: {top: number, left: number, height: number, width: number, padding: number}
位置、大小和 padding，只读。

// style (main)
var root = Parser.parse('a\n[[b]]'),
	{firstChild, lastChild} = root;
assert.equal(lastChild, '[[b]]');
assert.deepStrictEqual(root.style, {
	top: 0,
	left: 0,
	height: 2,
	width: 5,
	padding: 0,
});
assert.deepStrictEqual(firstChild.style, {
	top: 0,
	left: 0,
	height: 2,
	width: 0,
	padding: 0,
});
assert.deepStrictEqual(lastChild.style, {
	top: 1,
	left: 0,
	height: 1,
	width: 5,
	padding: 2, // `[[`
});

font

展开

加入的版本: 1.8.0

字体样式。

// font (main)
var {
	childNodes: [, text],
	lastChild: {lastChild},
} = Parser.parse("''a'''\n'''''[//b c''d]");
assert.equal(text, "a'");
assert.equal(lastChild, "c''d");
assert.deepStrictEqual(text.font, {
	italic: true,
	bold: false,
});
assert.deepStrictEqual(lastChild.firstChild.font, {
	italic: true,
	bold: true,
});
assert.deepStrictEqual(lastChild.lastChild.font, {
	italic: false,
	bold: true,
});

bold

展开

加入的版本: 1.8.0

是否粗体。

// bold (main)
var {
	childNodes: [, text],
	lastChild: {lastChild},
} = Parser.parse("''a'''\n'''''[//b c''d]");
assert.equal(text, "a'");
assert.equal(lastChild, "c''d");
assert(text.bold === false);
assert(lastChild.firstChild.bold === true);
assert(lastChild.lastChild.bold === true);

italic

展开

加入的版本: 1.8.0

是否斜体。

// italic (main)
var {
	childNodes: [, text],
	lastChild: {lastChild},
} = Parser.parse("''a'''\n'''''[//b c''d]");
assert.equal(text, "a'");
assert.equal(lastChild, "c''d");
assert(text.italic === true);
assert(lastChild.firstChild.italic === true);
assert(lastChild.lastChild.italic === false);

Methods

getRootNode

✅ 展开

returns: Token
获取根节点。

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

indexFromPos

✅ 展开

param: number 行号
param: number 列号
returns: number
将字符位置转换为行列号。

// indexFromPos
var root = Parser.parse('a\nb');
assert.strictEqual(root.indexFromPos(0, 0), 0);
assert.strictEqual(root.indexFromPos(0, 1), 1);
assert.strictEqual(root.indexFromPos(1, 0), 2);
assert.strictEqual(root.indexFromPos(1, 1), 3);
assert.strictEqual(root.indexFromPos(2, 0), undefined);

posFromIndex

✅ 展开

param: number 字符位置
returns: {top: number, left: number}
将字符位置转换为行列号。

// posFromIndex
var root = Parser.parse('a\nb');
assert.deepStrictEqual(root.posFromIndex(3), {top: 1, left: 1});
assert.strictEqual(root.posFromIndex(4), undefined);

getRelativeIndex

✅ 展开

returns: number
获取指定子节点（或当前节点自身）相对于其父节点的字符位置。

// getRelativeIndex
var root = Parser.parse('a[[b]]'),
	{lastChild} = root,
	{firstChild} = lastChild;
assert.equal(lastChild, '[[b]]');
assert.equal(firstChild, 'b');
assert.strictEqual(root.getRelativeIndex(), 0);
assert.strictEqual(root.getRelativeIndex(0), 0);
assert.strictEqual(root.getRelativeIndex(1), 1);
assert.strictEqual(root.getRelativeIndex(2), 6);
assert.strictEqual(lastChild.getRelativeIndex(), 1);
assert.strictEqual(lastChild.getRelativeIndex(0), 2);
// delimiter `|` is required to append a second child node
assert.strictEqual(lastChild.getRelativeIndex(1), 4);
assert.strictEqual(firstChild.getRelativeIndex(), 2);
assert.strictEqual(firstChild.getRelativeIndex(0), 0);

getAbsoluteIndex

✅ 展开

returns: number
获取当前节点的绝对位置。

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

getBoundingClientRect

✅ 展开

returns: {top: number, left: number, height: number, width: number}
获取当前节点的行列位置和大小。

// getBoundingClientRect
var {firstChild, lastChild} = Parser.parse('a\n[[b]]');
assert.equal(lastChild, '[[b]]');
assert.deepStrictEqual(firstChild.getBoundingClientRect(), {
	top: 0,
	left: 0,
	height: 2,
	width: 0,
});
assert.deepStrictEqual(lastChild.getBoundingClientRect(), {
	top: 1,
	left: 0,
	height: 1,
	width: 5,
});

is

✅ 展开

加入的版本：1.10.0

param: string Node type
returns: boolean
判断是否是指定类型的节点。

// is
var root = Parser.parse('a');
assert(root.is('root'));
assert(!root.firstChild.is('link'));

isEqualNode

展开

param: AstNode 待比较的节点
returns: boolean
是否是全同节点。

// isEqualNode (main)
var a = Parser.parse('[[a]]'),
	b = Parser.parse('[[a]]'),
	c = Parser.parse('[[ a]]'),
	d = a.firstChild,
	e = Parser.parse('<!--[[a]]-->').firstChild.firstChild,
	f = Parser.parse('[[a]]', true);
assert.equal(d, '[[a]]');
assert.equal(e, '[[a]]');
assert(a.isEqualNode(b));
assert(!a.isEqualNode(c));
assert(!a.isEqualNode(d));
assert(!a.isEqualNode(e));
assert(a.isEqualNode(f));
assert(!d.isEqualNode(e));

after

展开

param: AstNode | string 插入节点
在后方批量插入兄弟节点。

// after (main)
var root = Parser.parse('a'),
	{firstChild} = root;
firstChild.after('b', 'c');
assert.equal(root, 'abc');

before

展开

param: AstNode | string 插入节点
在前方批量插入兄弟节点。

// before (main)
var root = Parser.parse('a'),
	{firstChild} = root;
firstChild.before('b', 'c');
assert.equal(root, 'bca');

remove

展开

移除当前节点。

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

replaceWith

展开

param: AstNode | string 插入节点
将当前节点批量替换为新的节点。

// replaceWith (main)
var root = Parser.parse('a'),
	{firstChild} = root;
firstChild.replaceWith('b', 'c');
assert.equal(root, 'bc');

contains

展开

param: AstNode 待检测节点
是否是自身或后代节点。

// contains (main)
var root = Parser.parse('a'),
	{firstChild} = root;
assert(root.contains(root));
assert(root.contains(firstChild));
assert(!firstChild.contains(root));

addEventListener

展开

param: string | string[] 事件类型
param: Function 监听函数
param: {once?: boolean} 选项
添加事件监听。需搭配 dispatchEvent 方法使用。

// addEventListener (main)
var root = Parser.parse(''),
	counter = 0;
var listener = (_, data) => {
	counter += data;
};
root.addEventListener('x', listener);
root.addEventListener('y', listener, {once: true});
root.dispatchEvent(new Event('x'), 1);
assert.strictEqual(counter, 1);
root.dispatchEvent(new Event('x'), 2);
assert.strictEqual(counter, 3);
root.dispatchEvent(new Event('y'), 3);
assert.strictEqual(counter, 6);
root.dispatchEvent(new Event('y'), 4);
assert.strictEqual(counter, 6);

removeEventListener

展开

param: string | string[] 事件类型
param: Function 监听函数
移除事件监听。

// removeEventListener (main)
var root = Parser.parse(''),
	counter = 0;
var listener = () => {
	counter++;
};
root.addEventListener('x', listener);
root.addEventListener('y', listener);
root.addEventListener('z', listener);
root.dispatchEvent(new Event('x'));
assert.strictEqual(counter, 1);
root.dispatchEvent(new Event('y'));
assert.strictEqual(counter, 2);
root.dispatchEvent(new Event('z'));
assert.strictEqual(counter, 3);
root.removeEventListener('x', listener);
root.dispatchEvent(new Event('x'));
assert.strictEqual(counter, 3);
root.dispatchEvent(new Event('y'));
assert.strictEqual(counter, 4);
root.dispatchEvent(new Event('z'));
assert.strictEqual(counter, 5);
root.removeEventListener(['y', 'z'], listener);
root.dispatchEvent(new Event('y'));
root.dispatchEvent(new Event('z'));
assert.strictEqual(counter, 5);

removeAllEventListeners

展开

param: string | string[] 事件类型
移除事件的所有监听。

// removeAllEventListeners (main)
var root = Parser.parse(''),
	counter = 0;
var f = () => {
	counter++;
};
var g = () => {
	counter += 2;
};
root.addEventListener('x', f);
root.addEventListener('x', g);
root.addEventListener('y', f);
root.addEventListener('z', g);
root.dispatchEvent(new Event('x'));
assert.strictEqual(counter, 3);
root.dispatchEvent(new Event('y'));
assert.strictEqual(counter, 4);
root.dispatchEvent(new Event('z'));
assert.strictEqual(counter, 6);
root.removeAllEventListeners('x');
root.dispatchEvent(new Event('x'));
assert.strictEqual(counter, 6);
root.dispatchEvent(new Event('y'));
assert.strictEqual(counter, 7);
root.dispatchEvent(new Event('z'));
assert.strictEqual(counter, 9);
root.removeAllEventListeners(['y', 'z']);
root.dispatchEvent(new Event('y'));
root.dispatchEvent(new Event('z'));
assert.strictEqual(counter, 9);

listEventListeners

展开

param: string 事件类型
列举事件监听。

// listEventListeners (main)
var {firstChild} = Parser.parse('[[a]]'),
	listeners = firstChild.listEventListeners('remove');
assert.strictEqual(listeners.length, 1);
assert.strictEqual(listeners[0].name, 'linkListener'); // 解析器预置的监听函数

dispatchEvent

展开

param: Event 事件对象
param: any 事件数据
触发事件。

// dispatchEvent (main)
var root = Parser.parse('a'),
	{firstChild} = root,
	record = '';
var listener = ({target, currentTarget, prevTarget}) => {
	record += `${target.type} ${currentTarget.type} ${prevTarget?.type}\n`;
};
root.addEventListener('x', listener, {once: true});
firstChild.addEventListener('x', listener);
firstChild.dispatchEvent(new Event('x', {bubbles: true}));
assert.strictEqual(record, 'text text undefined\ntext root text\n');
firstChild.dispatchEvent(new Event('x', {bubbles: true}));
assert.strictEqual(
	record,
	'text text undefined\ntext root text\ntext text undefined\n',
);

getAncestors

展开

returns: Token[]
获取所有祖先节点（自下而上）。

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

compareDocumentPosition

展开

param: AstNode
returns: number
比较和另一个节点的相对位置。

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

destroy

展开

销毁节点。会连锁销毁所有祖先节点，所以使用前请先使用 remove 方法从父节点上剥离。

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

getLine

展开

param: number 行号
returns: string
获取某一行的源文本。

// getLine (main)
assert.strictEqual(Parser.parse('a\nb').getLine(1), 'b');

Related NPM Packages

WikiLint

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

eslint-plugin-wikitext

ESLint plugin for Wikitext

AstNode

Other Languages

简介

Properties

childNodes

firstChild

lastChild

parentNode

nextSibling

previousSibling

offsetHeight

offsetWidth

nextElementSibling

previousElementSibling

nextVisibleSibling

previousVisibleSibling

isConnected

eof

offsetTop

offsetLeft

style

font

bold

italic

Methods

getRootNode

indexFromPos

posFromIndex

getRelativeIndex

getAbsoluteIndex

getBoundingClientRect

is

isEqualNode

after

before

remove

replaceWith

contains

addEventListener

removeEventListener

removeAllEventListeners

listEventListeners

dispatchEvent

getAncestors

compareDocumentPosition

destroy

getLine

相关 NPM 包

Related NPM Packages

Clone this wiki locally