Skip to content

TranscludeToken

Jump to bottom
Bhsd edited this page Dec 6, 2024 · 23 revisions
目录

Other Languages

简介

模板或魔术字。

✅ 在 Mini 和 Browser 版本中可用。

Properties

modifier

✅ 展开

type: string
subst 和 safesubst 等，包含 :，只读。

// modifier
var magicWord = Parser
	.parse('<includeonly>{{subst:REVISIONUSER}}</includeonly>', true)
	.querySelector('magic-word');
assert.equal(magicWord, '{{subst:REVISIONUSER}}');
assert.strictEqual(magicWord.modifier, 'subst:');

name

展开

type: string
模板名（含名字空间）或魔术字，只读。

// name (main)
var {firstChild, lastChild} = Parser.parse('{{a}}{{!}}');
assert.equal(firstChild, '{{a}}');
assert.equal(lastChild, '{{!}}');
assert.strictEqual(firstChild.name, 'Template:A');
assert.strictEqual(lastChild.name, '!');
firstChild.firstChild.setText('b', 0);
assert.strictEqual(firstChild.name, 'Template:B');

duplication

展开

type: boolean
是否存在重复参数。

// duplication (main)
var {firstChild} = Parser.parse('{{a|b|1=b}}');
assert.equal(firstChild, '{{a|b|1=b}}');
assert(firstChild.duplication);

Methods

setModifier

✅ 展开

param: string 引用修饰符
设置引用修饰符。

// setModifier
var {firstChild} = Parser.parse('{{a}}');
assert.equal(firstChild, '{{a}}');
firstChild.setModifier('subst:');
assert.equal(firstChild, '{{subst:a}}');

isTemplate

✅ 展开

returns: boolean
是否是模板或模块。

// isTemplate
var {firstChild, lastChild} = Parser.parse('{{a}}{{!}}');
assert.equal(firstChild, '{{a}}');
assert.equal(lastChild, '{{!}}');
assert(firstChild.isTemplate());
assert(!lastChild.isTemplate());

lint

✅ 展开

returns: LintError[]
报告潜在语法错误。

// lint
var [a, b] = Parser.parse(`{{#invoke:[a]}}{{#invoke:b#b|b|b=1|b=2}}`)
	.querySelectorAll('magic-word');
assert.equal(a, '{{#invoke:[a]}}');
assert.equal(b, '{{#invoke:b#b|b|b=1|b=2}}');
assert.deepStrictEqual(a.lint(), [
	{
		rule: 'invalid-invoke',
		severity: 'error',
		message: 'illegal module name',
		startLine: 0,
		startCol: 10,
		startIndex: 10,
		endLine: 0,
		endCol: 13,
		endIndex: 13,
	},
	{
		rule: 'invalid-invoke',
		severity: 'error',
		message: 'missing module function',
		startLine: 0,
		startCol: 0,
		startIndex: 0,
		endLine: 0,
		endCol: 15,
		endIndex: 15,
	},
]);
assert.deepStrictEqual(b.lint(), [
	{
		rule: 'no-ignored',
		severity: 'error',
		message: 'useless fragment',
		startLine: 0,
		startCol: 25,
		startIndex: 25,
		endLine: 0,
		endCol: 28,
		endIndex: 28,
		fix: {
			range: [26, 28],
			text: '',
			desc: 'remove',
		},
	},
	{
		rule: 'no-duplicate',
		severity: 'error',
		message: 'duplicated parameter',
		startLine: 0,
		startCol: 31,
		startIndex: 31,
		endLine: 0,
		endCol: 34,
		endIndex: 34,
		suggestions: [
			{
				desc: 'remove',
				range: [30, 34],
				text: '',
			},
		],
	},
	{
		rule: 'no-duplicate',
		severity: 'error',
		message: 'duplicated parameter',
		startLine: 0,
		startCol: 35,
		startIndex: 35,
		endLine: 0,
		endCol: 38,
		endIndex: 38,
		suggestions: [
			{
				desc: 'remove',
				range: [34, 38],
				text: '',
			},
		],
	},
]);

getAllArgs

✅ 展开

returns: ParameterToken[]
获取所有参数。

// getAllArgs
var {firstChild} = Parser.parse('{{a|b|c=1}}');
assert.equal(firstChild, '{{a|b|c=1}}');
assert.deepStrictEqual(
	firstChild.getAllArgs(),
	firstChild.querySelectorAll('parameter'),
);

getAnonArgs

✅ 展开

returns: ParameterToken[]
获取所有匿名参数。

// getAnonArgs
var {firstChild} = Parser.parse('{{a|b|c=1}}');
assert.equal(firstChild, '{{a|b|c=1}}');
assert.deepStrictEqual(
	firstChild.getAnonArgs(),
	[firstChild.querySelector('parameter')],
);

getArgs

✅ 展开

param: string | number
returns: Set<ParameterToken>
获取指定参数。

// getArgs
var {firstChild} = Parser.parse('{{a|b|1=c}}');
assert.equal(firstChild, '{{a|b|1=c}}');
assert.deepStrictEqual(
	firstChild.getArgs(1),
	new Set(firstChild.querySelectorAll('parameter')),
);

getDuplicatedArgs

✅ 展开

returns: [string, ParameterToken[]][]
获取重名参数。

// getDuplicatedArgs
var {firstChild} = Parser.parse('{{a|b|1=c}}');
assert.equal(firstChild, '{{a|b|1=c}}');
assert.deepStrictEqual(
	firstChild.getDuplicatedArgs(),
	[['1', firstChild.querySelectorAll('parameter')]],
);

getPossibleValues

✅ 展开

returns: Token[]
对特定魔术字获取可能的取值。

// getPossibleValues
var {firstChild} = Parser.parse('{{#if:a|b|c}}'),
	{childNodes: [, a, b, c]} = firstChild;
assert.equal(firstChild, '{{#if:a|b|c}}');
assert.equal(a, 'a');
assert.equal(b, 'b');
assert.equal(c, 'c');
assert.deepStrictEqual(
	firstChild.getPossibleValues(),
	[b.lastChild, c.lastChild],
);

cloneNode

展开

returns: this
深拷贝节点。

// cloneNode (main)
var {firstChild, lastChild} = Parser.parse('{{a}}{{!}}');
assert.equal(firstChild, '{{a}}');
assert.equal(lastChild, '{{!}}');
assert.deepStrictEqual(firstChild.cloneNode(), firstChild);
assert.deepStrictEqual(lastChild.cloneNode(), lastChild);

subst

展开

替换引用。

// subst (main)
var {firstChild} = Parser.parse('{{a}}');
assert.equal(firstChild, '{{a}}');
firstChild.subst();
assert.equal(firstChild, '{{subst:a}}');

safesubst

展开

安全的替换引用。

// safesubst (main)
var {firstChild} = Parser.parse('{{a}}');
assert.equal(firstChild, '{{a}}');
firstChild.safesubst();
assert.equal(firstChild, '{{safesubst:a}}');

hasArg

展开

param: string | number 参数名
returns: boolean
是否具有某参数。

// hasArg (main)
var {firstChild} = Parser.parse('{{a|b}}');
assert.equal(firstChild, '{{a|b}}');
assert(firstChild.hasArg(1));

getArg

展开

param: string | number 参数名
returns: ParameterToken
获取生效的指定参数。

// getArg (main)
var {firstChild} = Parser.parse('{{a|b|1=c}}');
assert.equal(firstChild, '{{a|b|1=c}}');
assert.strictEqual(firstChild.getArg(1), firstChild.lastChild);

removeArg

展开

param: string | number 参数名
移除指定参数。

// removeArg (main)
var {firstChild} = Parser.parse('{{a|b}}');
assert.equal(firstChild, '{{a|b}}');
firstChild.removeArg(1);
assert.equal(firstChild, '{{a}}');

getKeys

展开

returns: string[]
获取所有参数名。

// getKeys (main)
var {firstChild} = Parser.parse('{{a|b|c=1}}');
assert.equal(firstChild, '{{a|b|c=1}}');
assert.deepStrictEqual(firstChild.getKeys(), ['1', 'c']);
firstChild.lastChild.firstChild.setText('d', 0);
assert.deepStrictEqual(firstChild.getKeys(), ['1', 'd']);

getValues

展开

param: string | number 参数名
returns: string[]
获取参数值。

// getValues (main)
var {firstChild} = Parser.parse('{{a|b|1=c}}');
assert.equal(firstChild, '{{a|b|1=c}}');
assert.deepStrictEqual(firstChild.getValues(1), ['b', 'c']);

getValue

展开

param: string | number 参数名
returns: string
获取生效的指定参数值。

// getValue (main)
var {firstChild} = Parser.parse('{{a|b|1=c}}');
assert.equal(firstChild, '{{a|b|1=c}}');
assert.deepStrictEqual(firstChild.getValue(1), 'c');

newAnonArg

展开

param: string 参数值
插入匿名参数。

// newAnonArg (main)
var {firstChild} = Parser.parse('{{a}}');
assert.equal(firstChild, '{{a}}');
firstChild.newAnonArg('b');
assert.equal(firstChild, '{{a|b}}');

setValue

展开

param: string 参数名
param: string 参数值
设置参数值。

// setValue (main)
var {firstChild} = Parser.parse('{{a|b}}');
assert.equal(firstChild, '{{a|b}}');
firstChild.setValue('1', 'c');
firstChild.setValue('2', 'd');
assert.equal(firstChild, '{{a|c|2=d}}');

anonToNamed

展开

将匿名参数改写为命名参数。

// anonToNamed (main)
var {firstChild} = Parser.parse('{{a|b|c}}');
assert.equal(firstChild, '{{a|b|c}}');
firstChild.anonToNamed();
assert.equal(firstChild, '{{a|1=b|2=c}}');

replaceTemplate

展开

param: string 模板名
替换模板名。

// replaceTemplate (main)
var {firstChild} = Parser.parse('{{a}}');
assert.equal(firstChild, '{{a}}');
firstChild.replaceTemplate('b');
assert.equal(firstChild, '{{b}}');

replaceModule

展开

param: string 模块名
替换模块名。

// replaceModule (main)
var {firstChild} = Parser.parse('{{#invoke:a|b}}');
assert.equal(firstChild, '{{#invoke:a|b}}');
firstChild.replaceModule('c');
assert.equal(firstChild, '{{#invoke:c|b}}');

replaceFunction

展开

param: string 模块函数名
替换模块函数。

// replaceFunction (main)
var {firstChild} = Parser.parse('{{#invoke:a|b}}');
assert.equal(firstChild, '{{#invoke:a|b}}');
firstChild.replaceFunction('c');
assert.equal(firstChild, '{{#invoke:a|c}}');

hasDuplicatedArgs

展开

returns: number
重复参数计数。

// hasDuplicatedArgs (main)
var {firstChild} = Parser.parse('{{a|b|1=c}}');
assert.equal(firstChild, '{{a|b|1=c}}');
assert.strictEqual(firstChild.hasDuplicatedArgs(), 1);

fixDuplication

展开

returns: string[]
修复重名参数。

// fixDuplication (main)
var {firstChild} = Parser.parse('{{a|b|1=b|1=}}');
assert.equal(firstChild, '{{a|b|1=b|1=}}');
firstChild.fixDuplication();
assert.equal(firstChild, '{{a|b}}');

escapeTables

展开

returns: this
转义模板内的表格。

// escapeTables (main)
var root = Parser.parse('{{a|b=c\n{|\n|-\n|rowspan=2|d\n|}\n}}'),
	{firstChild} = root;
assert.equal(firstChild, '{{a|b=c\n{|\n|-\n|rowspan=2|d\n|}\n}}');
firstChild.escapeTables();
assert.equal(
	root.toString(),
	'{{a|b=c\n{{{!}}\n{{!}}-\n{{!}}rowspan=2{{!}}d\n{{!}}}\n}}',
);

相关 NPM 包

WikiLint

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

eslint-plugin-wikitext

用于维基文本的 ESLint 插件

Related NPM Packages

WikiLint

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

eslint-plugin-wikitext

ESLint plugin for Wikitext

Clone this wiki locally