Skip to content

LanguageService (EN)

Jump to bottom
Bhsd edited this page Feb 10, 2025 · 5 revisions
Table of Contents

Other Languages

Introduction

The LanguageService object is created by the Parser.createLanguageService method and used for language services.

All of the following properties and methods are available in the Mini version.

🌐 Available in the Browser version.

Methods

destroy

🌐 Expand

Destroy the instance.

// destroy
var lsp = Parser.createLanguageService({});
lsp.destroy();
assert.strictEqual(lsp.provideDiagnostics, undefined);

provideDocumentColors

🌐 Expand

param: (s: string) => [number, number, number, number] | [] The function to parse the color string.
param: string The wikitext content.
returns: Promise<ColorInformation[]>
List all color references found in the document.

// provideDocumentColors
(async () => {
	var rgba = (await import('color-rgba')).default;
	var lsp = Parser.createLanguageService({}),
		wikitext = `
<p style="color: rgba(255, 0, 0, .7)">
<poem style="color: #00ff00ff"/>
{{#tag:font|color=#f000}}
{{color|rgb(0 0 255 / 50%)}}
{{color|1=hsla(0, 100%, 50%, 0.5)}}
{{{|hsl(0deg 100 50)}}}
`;
	assert.deepStrictEqual(
		await lsp.provideDocumentColors(rgba, wikitext),
		[
			{
				range: {
					start: {line: 1, character: 17},
					end: {line: 1, character: 36},
				},
				color: {red: 1, green: 0, blue: 0, alpha: 0.7},
			},
			{
				range: {
					start: {line: 2, character: 20},
					end: {line: 2, character: 29},
				},
				color: {red: 0, green: 1, blue: 0, alpha: 1},
			},
			{
				range: {
					start: {line: 3, character: 18},
					end: {line: 3, character: 23},
				},
				color: {red: 1, green: 0, blue: 0, alpha: 0},
			},
			{
				range: {
					start: {line: 4, character: 8},
					end: {line: 4, character: 26},
				},
				color: {red: 0, green: 0, blue: 1, alpha: 0.5},
			},
			{
				range: {
					start: {line: 5, character: 10},
					end: {line: 5, character: 33},
				},
				color: {red: 1, green: 0, blue: 0, alpha: 0.5},
			},
			{
				range: {
					start: {line: 6, character: 4},
					end: {line: 6, character: 20},
				},
				color: {red: 1, green: 0, blue: 0, alpha: 1},
			},
		],
	);
})();

provideColorPresentations

🌐 Expand

param: ColorPresentationParams
returns: ColorPresentation[]
Obtain a list of presentations for a color value at a given location.

// provideColorPresentations
var lsp = Parser.createLanguageService({}),
	range = {
		start: {line: 0, character: 0},
		end: {line: 0, character: 1},
	};
assert.deepStrictEqual(
	lsp.provideColorPresentations({
		color: {red: 1, green: 0, blue: 0, alpha: 0.5},
		range,
	}),
	[
		{
			label: '#ff000080',
			textEdit: {range, newText: '#ff000080'},
		},
	],
);
assert.deepStrictEqual(
	lsp.provideColorPresentations({
		color: {red: 0, green: 0.9, blue: 0, alpha: 1},
		range,
	}),
	[
		{
			label: '#00e600',
			textEdit: {range, newText: '#00e600'},
		},
	],
);

provideCompletionItems

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<CompletionItem[] | undefined>
Compute completion items at a given cursor position.

// provideCompletionItems
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
<Im
{{{ a }}}
[[ a ]]
[[ : file : b ]]
{{ #Ifexp
{{ pagenamee }}
__T
[Gi
[[ file : c | Thumbnail | 100x100px ]]
[[ file : c | 100px ]]
<poem C
<ref n
<p Da
{{ c | c | CC = }}
`;
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 1, character: 3}))
			?.filter(({label}) => label.startsWith('im')),
		[
			{
				label: 'imagemap',
				kind: 'Class',
				textEdit: {
					range: {
						start: {line: 1, character: 1},
						end: {line: 1, character: 3},
					},
					newText: 'imagemap',
				},
			},
			{
				label: 'img',
				kind: 'Class',
				textEdit: {
					range: {
						start: {line: 1, character: 1},
						end: {line: 1, character: 3},
					},
					newText: 'img',
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideCompletionItems(wikitext, {line: 2, character: 5}),
		[
			{
				label: 'a',
				kind: 'Variable',
				textEdit: {
					range: {
						start: {line: 2, character: 4},
						end: {line: 2, character: 5},
					},
					newText: 'a',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 3, character: 4}))
			?.filter(({label}) => /^a/iu.test(label)),
		[
			{
				label: 'A',
				kind: 'Folder',
				textEdit: {
					range: {
						start: {line: 3, character: 3},
						end: {line: 3, character: 4},
					},
					newText: 'A',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 4, character: 11}))
			?.filter(({label}) => /^file:/iu.test(label)),
		[
			{
				label: 'File:B',
				kind: 'Folder',
				textEdit: {
					range: {
						start: {line: 4, character: 5},
						end: {line: 4, character: 11},
					},
					newText: 'File:B',
				},
			},
			{
				label: 'File:C',
				kind: 'Folder',
				textEdit: {
					range: {
						start: {line: 4, character: 5},
						end: {line: 4, character: 11},
					},
					newText: 'File:C',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 5, character: 9}))
			?.filter(({label}) => /^#ifexp/iu.test(label)),
		[
			{
				label: '#ifexpr',
				kind: 'Function',
				textEdit: {
					range: {
						start: {line: 5, character: 3},
						end: {line: 5, character: 9},
					},
					newText: '#ifexpr',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 6, character: 12}))
			?.filter(({label}) => /^pagenamee/iu.test(label)),
		[
			{
				label: 'PAGENAMEE',
				kind: 'Function',
				textEdit: {
					range: {
						start: {line: 6, character: 3},
						end: {line: 6, character: 12},
					},
					newText: 'PAGENAMEE',
				},
			},
			{
				label: 'Pagenamee',
				kind: 'Folder',
				textEdit: {
					range: {
						start: {line: 6, character: 3},
						end: {line: 6, character: 12},
					},
					newText: 'Pagenamee',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 7, character: 3}))
			?.filter(({label}) => /^__t/iu.test(label)),
		[
			{
				label: '__toc__',
				kind: 'Constant',
				textEdit: {
					range: {
						start: {line: 7, character: 0},
						end: {line: 7, character: 3},
					},
					newText: '__toc__',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 8, character: 3}))
			?.filter(({label}) => label.startsWith('gi')),
		[
			{
				label: 'git://',
				kind: 'Reference',
				textEdit: {
					range: {
						start: {line: 8, character: 1},
						end: {line: 8, character: 3},
					},
					newText: 'git://',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 9, character: 20}))
			?.filter(({label}) => label.startsWith('thumbn')),
		[
			{
				label: 'thumbnail',
				kind: 'Property',
				textEdit: {
					range: {
						start: {line: 9, character: 14},
						end: {line: 9, character: 20},
					},
					newText: 'thumbnail',
				},
			},
			{
				label: 'thumbnail=',
				kind: 'Property',
				textEdit: {
					range: {
						start: {line: 9, character: 14},
						end: {line: 9, character: 20},
					},
					newText: 'thumbnail=',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 10, character: 15}))
			?.filter(({label}) => label.startsWith('1')),
		[
			{
				label: '100x100px',
				kind: 'Unit',
				textEdit: {
					range: {
						start: {line: 10, character: 14},
						end: {line: 10, character: 15},
					},
					newText: '100x100px',
				},
			},
			{
				label: '100px',
				kind: 'Unit',
				textEdit: {
					range: {
						start: {line: 10, character: 14},
						end: {line: 10, character: 15},
					},
					newText: '100px',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 11, character: 7}))
			?.filter(({label}) => label.startsWith('c')),
		[
			{
				label: 'compact',
				kind: 'Field',
				textEdit: {
					range: {
						start: {line: 11, character: 6},
						end: {line: 11, character: 7},
					},
					newText: 'compact',
				},
			},
			{
				label: 'class',
				kind: 'Property',
				textEdit: {
					range: {
						start: {line: 11, character: 6},
						end: {line: 11, character: 7},
					},
					newText: 'class',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 12, character: 6}))
			?.filter(({label}) => label.startsWith('n')),
		[
			{
				label: 'name',
				kind: 'Field',
				textEdit: {
					range: {
						start: {line: 12, character: 5},
						end: {line: 12, character: 6},
					},
					newText: 'name',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 13, character: 5}))
			?.filter(({label}) => label.startsWith('da')),
		[
			{
				label: 'datatype',
				kind: 'Property',
				textEdit: {
					range: {
						start: {line: 13, character: 3},
						end: {line: 13, character: 5},
					},
					newText: 'datatype',
				},
			},
			{
				label: 'data-',
				kind: 'Variable',
				textEdit: {
					range: {
						start: {line: 13, character: 3},
						end: {line: 13, character: 5},
					},
					newText: 'data-',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 14, character: 8}))
			?.filter(({label}) => /^c/iu.test(label)),
		[
			{
				label: 'CC',
				kind: 'Variable',
				textEdit: {
					range: {
						start: {line: 14, character: 6},
						end: {line: 14, character: 8},
					},
					newText: 'CC',
				},
			},
		],
	);
})();

provideFoldingRanges

🌐 Expand

param: string The wikitext content.
returns: Promise<FoldingRange[]>
Return all folding ranges found in a given document.

// provideFoldingRanges
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
<!--

-->= 1 =

<!-- -->

<!-- -->== 2 ==



===== 3 ===== <!--

--> 

x {{a|
====== 4_<!--
-->2 ====== 
y }} z

== 4 ==


= 4 =

 : {|
|
=== 4 ===
 |} x

`;
	assert.deepStrictEqual(
		await lsp.provideFoldingRanges(wikitext),
		[
			{startLine: 15, endLine: 17, kind: 'region'},
			{startLine: 7, endLine: 19, kind: 'region'},
			{startLine: 11, endLine: 19, kind: 'region'},
			{startLine: 17, endLine: 19, kind: 'region'},
			{startLine: 3, endLine: 22, kind: 'region'},
			{startLine: 20, endLine: 22, kind: 'region'},
			{startLine: 25, endLine: 27, kind: 'region'},
			{startLine: 23, endLine: 30, kind: 'region'},
			{startLine: 27, endLine: 30, kind: 'region'},
		],
	);
})();

provideLinks

🌐 Expand

param: string The wikitext content.
returns: Promise<DocumentLink[]>
Request the location of links in a document.

// provideLinks
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
[[ : help : a#a ]]
{{ b }}
{{ #invoke: c | c }}
RFC 1
PMID 1
ISBN 1-2-3-4-5-6-7-8-9-0
[//d d]
News:e
<templatestyles src = f />
<q cite = "HTTPS://G/G">
[[file:a|link=a]]
[[file:a|link=//a]]
`,
		results = [
			{
				range: {
					start: {line: 1, character: 2},
					end: {line: 1, character: 16},
				},
				target: 'https://mediawiki.org/wiki/Help%3AA#a',
			},
			{
				range: {
					start: {line: 2, character: 2},
					end: {line: 2, character: 5},
				},
				target: 'https://mediawiki.org/wiki/Template%3AB',
			},
			{
				range: {
					start: {line: 3, character: 11},
					end: {line: 3, character: 14},
				},
				target: 'https://mediawiki.org/wiki/Module%3AC',
			},
			{
				range: {
					start: {line: 4, character: 0},
					end: {line: 4, character: 5},
				},
				target: 'https://tools.ietf.org/html/rfc1',
			},
			{
				range: {
					start: {line: 5, character: 0},
					end: {line: 5, character: 6},
				},
				target: 'https://pubmed.ncbi.nlm.nih.gov/1',
			},
			{
				range: {
					start: {line: 6, character: 0},
					end: {line: 6, character: 24},
				},
				// eslint-disable-next-line @stylistic/max-len
				target: 'https://mediawiki.org/wiki/Special%3ABooksources%2F1234567890',
			},
			{
				range: {
					start: {line: 7, character: 1},
					end: {line: 7, character: 4},
				},
				target: 'https://d/',
			},
			{
				range: {
					start: {line: 8, character: 0},
					end: {line: 8, character: 6},
				},
				target: 'news:e',
			},
			{
				range: {
					start: {line: 9, character: 22},
					end: {line: 9, character: 23},
				},
				target: 'https://mediawiki.org/wiki/Template%3AF',
			},
			{
				range: {
					start: {line: 10, character: 11},
					end: {line: 10, character: 22},
				},
				target: 'https://g/G',
			},
			{
				range: {
					start: {line: 11, character: 2},
					end: {line: 11, character: 8},
				},
				target: 'https://mediawiki.org/wiki/File%3AA',
			},
			{
				range: {
					start: {line: 11, character: 14},
					end: {line: 11, character: 15},
				},
				target: 'https://mediawiki.org/wiki/A',
			},
			{
				range: {
					start: {line: 12, character: 2},
					end: {line: 12, character: 8},
				},
				target: 'https://mediawiki.org/wiki/File%3AA',
			},
			{
				range: {
					start: {line: 12, character: 14},
					end: {line: 12, character: 17},
				},
				target: 'https://a/',
			},
		];
	Parser.getConfig();
	Parser.config.articlePath = 'https://mediawiki.org/wiki/$1';
	assert.deepStrictEqual(await lsp.provideLinks(wikitext), results);
	Parser.config.articlePath = 'https://mediawiki.org/wiki/';
	assert.deepStrictEqual(await lsp.provideLinks(wikitext), results);
	Parser.config.articlePath = 'https://mediawiki.org/wiki';
	assert.deepStrictEqual(await lsp.provideLinks(wikitext), results);
	Parser.config.articlePath = '//mediawiki.org/wiki/$1';
	assert.deepStrictEqual(await lsp.provideLinks(wikitext), results);
})();

provideReferences

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<Omit<Location, 'uri'>[] | undefined>
Resolve references for the symbol denoted by the given document position.

// provideReferences
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
{{{ a }}}
{{{a|}}}
{{ b }}
{{ : template : b |b=}}
{{ PAGENAME }}
{{PAGENAME:c}}
[[ file : d | thumb ]]
[[ :file:d ]]
{{ e | e = }}
{{Template:E|e=}}
<ref group = f name = f > </ref>
<ref group = " f " extends = ' f ' />
<b></b>
<references group = f />
[[file:g|thumbnail]]
== h ==
== i ==
`;
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 1, character: 4}),
		[
			{
				range: {
					start: {line: 1, character: 3},
					end: {line: 1, character: 6},
				},
			},
			{
				range: {
					start: {line: 2, character: 3},
					end: {line: 2, character: 4},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 3, character: 4}),
		[
			{
				range: {
					start: {line: 3, character: 2},
					end: {line: 3, character: 5},
				},
			},
			{
				range: {
					start: {line: 4, character: 2},
					end: {line: 4, character: 18},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 5, character: 4}),
		[
			{
				range: {
					start: {line: 5, character: 2},
					end: {line: 5, character: 12},
				},
			},
			{
				range: {
					start: {line: 6, character: 2},
					end: {line: 6, character: 10},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 7, character: 4}),
		[
			{
				range: {
					start: {line: 7, character: 2},
					end: {line: 7, character: 12},
				},
			},
			{
				range: {
					start: {line: 8, character: 2},
					end: {line: 8, character: 11},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 9, character: 8}),
		[
			{
				range: {
					start: {line: 9, character: 6},
					end: {line: 9, character: 11},
				},
			},
			{
				range: {
					start: {line: 10, character: 13},
					end: {line: 10, character: 15},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 11, character: 2}),
		[
			{
				range: {
					start: {line: 11, character: 0},
					end: {line: 11, character: 32},
				},
			},
			{
				range: {
					start: {line: 12, character: 0},
					end: {line: 12, character: 37},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 13, character: 2}),
		[
			{
				range: {
					start: {line: 13, character: 0},
					end: {line: 13, character: 3},
				},
			},
			{
				range: {
					start: {line: 13, character: 3},
					end: {line: 13, character: 7},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 11, character: 6}),
		[
			{
				range: {
					start: {line: 11, character: 5},
					end: {line: 11, character: 10},
				},
			},
			{
				range: {
					start: {line: 12, character: 5},
					end: {line: 12, character: 10},
				},
			},
			{
				range: {
					start: {line: 14, character: 12},
					end: {line: 14, character: 17},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 15, character: 10}),
		[
			{
				range: {
					start: {line: 7, character: 13},
					end: {line: 7, character: 20},
				},
			},
			{
				range: {
					start: {line: 15, character: 9},
					end: {line: 15, character: 18},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 16, character: 4}),
		[
			{
				range: {
					start: {line: 16, character: 0},
					end: {line: 16, character: 7},
				},
			},
			{
				range: {
					start: {line: 17, character: 0},
					end: {line: 17, character: 7},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 16, character: 1}),
		[
			{
				range: {
					start: {line: 16, character: 0},
					end: {line: 16, character: 7},
				},
			},
			{
				range: {
					start: {line: 17, character: 0},
					end: {line: 17, character: 7},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 11, character: 23}),
		[
			{
				range: {
					start: {line: 11, character: 22},
					end: {line: 11, character: 23},
				},
			},
			{
				range: {
					start: {line: 12, character: 30},
					end: {line: 12, character: 33},
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 11, character: 14}),
		[
			{
				range: {
					start: {line: 11, character: 13},
					end: {line: 11, character: 14},
				},
			},
			{
				range: {
					start: {line: 12, character: 14},
					end: {line: 12, character: 17},
				},
			},
			{
				range: {
					start: {line: 14, character: 20},
					end: {line: 14, character: 21},
				},
			},
		],
	);
})();

provideDefinition

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<Omit<Location, 'uri'>[] | undefined>
Resolve the definition location of a symbol at a given document position.

// provideDefinition
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
{{{ a }}}
{{{a|}}}
{{ b }}
{{ : template : b |b=}}
{{ PAGENAME }}
{{PAGENAME:c}}
[[ file : d | thumb ]]
[[ :file:d ]]
{{ e | e = }}
{{Template:E|e=}}
<ref group = f name = f > </ref>
<ref group = " f " extends = ' f ' />
<b></b>
<references group = f />
[[file:g|thumbnail]]
== h ==
== i ==
`;
	assert.deepStrictEqual(
		await lsp.provideDefinition(wikitext, {line: 12, character: 32}),
		[
			{
				range: {
					start: {line: 11, character: 22},
					end: {line: 11, character: 23},
				},
			},
		],
	);
})();

resolveRenameLocation

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<Range | undefined>
Test the validity of a rename operation at a given location.

// resolveRenameLocation
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
{{{ a }}}
{{{a|}}}
{{ b }}
{{ : template : b |b=}}
{{ PAGENAME }}
{{PAGENAME:c}}
[[ file : d | thumb ]]
[[ :file:d ]]
{{ e | e = }}
{{Template:E|e=}}
<ref group = f name = f > </ref>
<ref group = " f " extends = ' f ' />
<b></b>
<references group = f />
[[file:g|thumbnail]]
== h ==
== i ==
`;
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 1, character: 4}),
		{
			start: {line: 1, character: 3},
			end: {line: 1, character: 6},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 3, character: 4}),
		{
			start: {line: 3, character: 2},
			end: {line: 3, character: 5},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 5, character: 4}),
		{
			start: {line: 5, character: 2},
			end: {line: 5, character: 12},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 7, character: 4}),
		{
			start: {line: 7, character: 2},
			end: {line: 7, character: 12},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 9, character: 8}),
		{
			start: {line: 9, character: 6},
			end: {line: 9, character: 9},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 11, character: 23}),
		{
			start: {line: 11, character: 22},
			end: {line: 11, character: 23},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 11, character: 14}),
		{
			start: {line: 11, character: 13},
			end: {line: 11, character: 14},
		},
	);
})();

provideRenameEdits

🌐 Expand

param: string The wikitext content.
param: Position
param: string The new name.
returns: Promise<WorkspaceEdit | undefined>
Compute a change for a document-wide rename of a symbol.

// provideRenameEdits
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
{{{ a }}}
{{{a|}}}
{{ b }}
{{ : template : b |b=}}
{{ PAGENAME }}
{{PAGENAME:c}}
[[ file : d | thumb ]]
[[ :file:d ]]
{{ e | e = }}
{{Template:E|e=}}
<ref group = f name = f > </ref>
<ref group = " f " extends = ' f ' />
<b></b>
<references group = f />
[[file:g|thumbnail]]
== h ==
== i ==
`;
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 1, character: 4}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 1, character: 3},
							end: {line: 1, character: 6},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 2, character: 3},
							end: {line: 2, character: 4},
						},
						newText: 'x',
					},
				],
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 3, character: 4}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 3, character: 2},
							end: {line: 3, character: 5},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 4, character: 2},
							end: {line: 4, character: 18},
						},
						newText: 'x',
					},
				],
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(
			wikitext,
			{line: 5, character: 4},
			'PAGENAMEE',
		),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 5, character: 2},
							end: {line: 5, character: 12},
						},
						newText: 'PAGENAMEE',
					},
					{
						range: {
							start: {line: 6, character: 2},
							end: {line: 6, character: 10},
						},
						newText: 'PAGENAMEE',
					},
				],
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 7, character: 4}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 7, character: 2},
							end: {line: 7, character: 12},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 8, character: 2},
							end: {line: 8, character: 11},
						},
						newText: 'x',
					},
				],
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 9, character: 8}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 9, character: 6},
							end: {line: 9, character: 9},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 10, character: 13},
							end: {line: 10, character: 14},
						},
						newText: 'x',
					},
				],
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 11, character: 23}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 11, character: 22},
							end: {line: 11, character: 23},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 12, character: 30},
							end: {line: 12, character: 33},
						},
						newText: 'x',
					},
				],
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 11, character: 14}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 11, character: 13},
							end: {line: 11, character: 14},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 12, character: 14},
							end: {line: 12, character: 17},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 14, character: 20},
							end: {line: 14, character: 21},
						},
						newText: 'x',
					},
				],
			},
		},
	);
})();

provideDiagnostics

🌐 Expand

param: string The wikitext content.
param: boolean Whether to include warnings.
returns: Promise<Diagnostic[]>
Compute the syntax diagnostics for a given document.

// provideDiagnostics
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
http://a]
</p>
`;
	assert.deepStrictEqual(
		await lsp.provideDiagnostics(wikitext),
		[
			{
				range: {
					start: {line: 1, character: 8},
					end: {line: 1, character: 9},
				},
				severity: 1,
				source: 'WikiLint',
				code: 'lonely-bracket',
				message: 'lonely "]"',
				data: [
					{
						range: {
							start: {line: 1, character: 0},
							end: {line: 1, character: 0},
						},
						newText: '[',
						title: 'Fix: left bracket',
						fix: true,
					},
				],
			},
			{
				range: {
					start: {line: 2, character: 0},
					end: {line: 2, character: 4},
				},
				severity: 1,
				source: 'WikiLint',
				code: 'unmatched-tag',
				message: 'unmatched closing tag',
				data: [
					{
						range: {
							start: {line: 2, character: 0},
							end: {line: 2, character: 4},
						},
						newText: '',
						title: 'Suggestion: remove',
						fix: false,
					},
				],
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideDiagnostics('['),
		[
			{
				range: {
					start: {line: 0, character: 0},
					end: {line: 0, character: 1},
				},
				severity: 2,
				source: 'WikiLint',
				code: 'lonely-bracket',
				message: 'lonely "["',
				data: [],
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideDiagnostics('[', false),
		[],
	);
})();

provideHover

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<Hover | undefined>
Request hover information at a given document position.

// provideHover (Node.js)
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
__NOTOC__
{{ #LEN: }}
{{ NUMBEROFPAGES }}
`;
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 1, character: 0}),
		{
			contents: {
				kind: 'markdown',
				value: 'Hides the table of contents (TOC).',
			},
			range: {
				start: {line: 1, character: 0},
				end: {line: 1, character: 9},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 2, character: 7}),
		{
			contents: {
				kind: 'markdown',
				value: `- **{{ #LEN:** *string* **}}**

The #len function returns the length of the given string.`,
			},
			range: {
				start: {line: 2, character: 2},
				end: {line: 2, character: 7},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 3, character: 4}),
		{
			contents: {
				kind: 'markdown',
				value: `- **{{ NUMBEROFPAGES** **}}**
- **{{ NUMBEROFPAGES:** R **}}**

Number of wiki pages.`,
			},
			range: {
				start: {line: 3, character: 2},
				end: {line: 3, character: 17},
			},
		},
	);
})();

provideSignatureHelp

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<SignatureHelp | undefined>
Request signature information of a magic word at a given cursor position. Once this method is called, the other methods will be disabled, vice versa.

// provideSignatureHelp (Node.js)
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
{{ #invoke: a | b | c | d }}
{{ PAGENAME }}
{{ PAGESIZE: a | R }}
`;
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 1, character: 12}),
		{
			signatures: [
				{
					label: '{{#invoke:module name|function name|args}}',
					parameters: [
						{label: 'module name'},
						{label: 'function name'},
						{label: 'args'},
					],
					activeParameter: 0,
				},
			],
			activeParameter: 0,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 1, character: 16}),
		{
			signatures: [
				{
					label: '{{#invoke:module name|function name|args}}',
					parameters: [
						{label: 'module name'},
						{label: 'function name'},
						{label: 'args'},
					],
					activeParameter: 1,
				},
			],
			activeParameter: 1,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 1, character: 25}),
		{
			signatures: [
				{
					label: '{{#invoke:module name|function name|args}}',
					parameters: [
						{label: 'module name'},
						{label: 'function name'},
						{label: 'args'},
					],
					activeParameter: 2,
				},
			],
			activeParameter: 3,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 2, character: 11}),
		{
			signatures: [
				{
					label: '{{PAGENAME}}',
					parameters: [],
				},
				{
					label: '{{PAGENAME:page name}}',
					parameters: [{label: 'page name'}],
				},
			],
			activeParameter: -1,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 3, character: 13}),
		{
			signatures: [
				{
					label: '{{PAGESIZE:page name|R}}',
					parameters: [
						{label: 'page name'},
						{label: 'R', documentation: 'Predefined parameter'},
					],
				},
			],
			activeParameter: 0,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 3, character: 17}),
		{
			signatures: [
				{
					label: '{{PAGESIZE:page name|R}}',
					parameters: [
						{label: 'page name'},
						{label: 'R', documentation: 'Predefined parameter'},
					],
				},
			],
			activeParameter: 1,
		},
	);
})();

provideInlayHints

🌐 Expand

version added: 1.16.2

param: string The wikitext content.
returns: Promise<InlayHint[]>
Compute inlay hints for a given document tuple that may be rendered in the editor in place with other text.

// provideInlayHints
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
{{a|b=|c}}
{{#invoke:a|b|c}}
`;
	assert.deepStrictEqual(
		await lsp.provideInlayHints(wikitext),
		[
			{
				position: {line: 1, character: 7},
				kind: 2,
				label: '1=',
			},
			{
				position: {line: 2, character: 14},
				kind: 2,
				label: '1=',
			},
		],
	);
})();

provideCodeAction

Expand

param: Diagnostic[]
returns: CodeAction[]
Compute commands for a given document and syntax diagnostic.

// provideCodeAction (Node.js)
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
http://a]
</p>
`,
		diagnostics = await lsp.provideDiagnostics(wikitext);
	assert.deepStrictEqual(
		lsp.provideCodeAction(diagnostics),
		[
			{
				title: 'Fix: left bracket',
				kind: 'quickfix',
				diagnostics: [diagnostics[0]],
				isPreferred: true,
				edit: {
					changes: {'': diagnostics[0].data},
				},
			},
			{
				title: 'Suggestion: remove',
				kind: 'quickfix',
				diagnostics: [diagnostics[1]],
				isPreferred: false,
				edit: {
					changes: {'': diagnostics[1].data},
				},
			},
		],
	);
})();

provideDocumentSymbols

Expand

param: string The wikitext content.
returns: Promise<DocumentSymbol[]>
Return a hierarchy of sections found in a given document.

// provideDocumentSymbols (Node.js)
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `
<!--

-->= 1 =

<!-- -->

<!-- -->== 2 ==



===== 3 ===== <!--

--> 

x {{a|
====== 4_<!--
-->2 ====== 
y }} z

== 4 ==


= 4 =

 : {|
|
=== 4 ===
 |} x

`;
	assert.deepStrictEqual(
		await lsp.provideDocumentSymbols(wikitext),
		[
			{
				name: '1',
				kind: 15,
				range: {
					start: {line: 3, character: 3},
					end: {line: 22, character: 0},
				},
				selectionRange: {
					start: {line: 3, character: 3},
					end: {line: 3, character: 8},
				},
				children: [
					{
						name: '2',
						kind: 15,
						range: {
							start: {line: 7, character: 8},
							end: {line: 19, character: 0},
						},
						selectionRange: {
							start: {line: 7, character: 8},
							end: {line: 7, character: 15},
						},
						children: [
							{
								name: '3',
								kind: 15,
								range: {
									start: {line: 11, character: 0},
									end: {line: 19, character: 0},
								},
								selectionRange: {
									start: {line: 11, character: 0},
									end: {line: 11, character: 13},
								},
								children: [
									{
										name: '4_2',
										kind: 15,
										range: {
											start: {line: 16, character: 0},
											end: {line: 19, character: 0},
										},
										selectionRange: {
											start: {line: 16, character: 0},
											end: {line: 17, character: 11},
										},
									},
								],
							},
						],
					},
					{
						name: '4',
						kind: 15,
						range: {
							start: {line: 20, character: 0},
							end: {line: 22, character: 0},
						},
						selectionRange: {
							start: {line: 20, character: 0},
							end: {line: 20, character: 7},
						},
					},
				],
			},
			{
				name: '4_3',
				kind: 15,
				range: {
					start: {line: 23, character: 0},
					end: {line: 30, character: 0},
				},
				selectionRange: {
					start: {line: 23, character: 0},
					end: {line: 23, character: 5},
				},
				children: [
					{
						name: '4_4',
						kind: 15,
						range: {
							start: {line: 27, character: 0},
							end: {line: 30, character: 0},
						},
						selectionRange: {
							start: {line: 27, character: 0},
							end: {line: 27, character: 9},
						},
					},
				],
			},
		],
	);
})();

相关 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