src/vs/platform/extensions/common/extensions.ts
570 LOC · 530 covered · 40 uncovered · 46 ranges · 3596 concepts · 17 introducers · 2063 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
extensions.ts ×24
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import Severity from '../../../base/common/severity.js';
7
>
import * as strings from '../../../base/common/strings.js';
8
>
import { URI } from '../../../base/common/uri.js';
9
>
import { ILocalizedString } from '../../action/common/action.js';
10
>
import { ExtensionKind } from '../../environment/common/environment.js';
11
>
import { createDecorator } from '../../instantiation/common/instantiation.js';
12
>
import { getRemoteName } from '../../remote/common/remoteHosts.js';
13
>
14
>
export const USER_MANIFEST_CACHE_FILE = 'extensions.user.cache';
15
>
export const BUILTIN_MANIFEST_CACHE_FILE = 'extensions.builtin.cache';
16
>
export const UNDEFINED_PUBLISHER = 'undefined_publisher';
17
>
18
>
export interface ICommand {
19
>
command: string;
20
>
title: string | ILocalizedString;
21
>
category?: string | ILocalizedString;
22
>
}
23
>
24
>
export interface IDebugger {
25
>
label?: string;
26
>
type: string;
27
>
runtime?: string;
28
>
}
29
>
30
>
export interface IGrammar {
31
>
language?: string;
32
>
}
33
>
34
>
export interface IJSONValidation {
35
>
fileMatch: string | string[];
36
>
url: string;
37
>
}
38
>
39
>
export interface IJSONValidationRegistry {
40
>
url: string;
41
>
}
42
>
43
>
export interface IKeyBinding {
44
>
command: string;
45
>
key: string;
46
>
when?: string;
47
>
mac?: string;
48
>
linux?: string;
49
>
win?: string;
50
>
}
51
>
52
>
export interface ILanguage {
53
>
id: string;
54
>
extensions: string[];
55
>
aliases: string[];
56
>
}
57
>
58
>
export interface IMenu {
59
>
command: string;
60
>
alt?: string;
61
>
when?: string;
62
>
group?: string;
63
>
}
64
>
65
>
export interface ISnippet {
66
>
language: string;
67
>
}
68
>
69
>
export interface ITheme {
70
>
label: string;
71
>
}
72
>
73
>
export interface IViewContainer {
74
>
id: string;
75
>
title: string;
76
>
}
77
>
78
>
export interface IView {
79
>
id: string;
80
>
name: string;
81
>
}
82
>
83
>
export interface IColor {
84
>
id: string;
85
>
description: string;
86
>
defaults: { light: string; dark: string; highContrast: string };
87
>
}
88
>
89
>
interface IWebviewEditor {
90
>
readonly viewType: string;
91
>
readonly priority: string;
92
>
readonly selector: readonly {
93
>
readonly filenamePattern?: string;
94
>
}[];
95
>
}
96
>
97
>
export interface ICodeActionContributionAction {
98
>
readonly kind: string;
99
>
readonly title: string;
100
>
readonly description?: string;
101
>
}
102
>
103
>
export interface ICodeActionContribution {
104
>
readonly languages: readonly string[];
105
>
readonly actions: readonly ICodeActionContributionAction[];
106
>
}
107
>
108
>
export interface IAuthenticationContribution {
109
>
readonly id: string;
110
>
readonly label: string;
111
>
readonly authorizationServerGlobs?: string[];
112
>
}
113
>
114
>
export interface IWalkthroughStep {
115
>
readonly id: string;
116
>
readonly title: string;
117
>
readonly description: string | undefined;
118
>
readonly media:
119
>
| { image: string | { dark: string; light: string; hc: string }; altText: string; markdown?: never; svg?: never; video?: never }
120
>
| { markdown: string; image?: never; svg?: never; video?: never }
121
>
| { svg: string; altText: string; markdown?: never; image?: never; video?: never }
122
>
| { video: string | { dark: string; light: string; hc: string }; poster: string | { dark: string; light: string; hc: string }; altText: string; markdown?: never; image?: never; svg?: never };
123
>
readonly completionEvents?: string[];
124
>
/** @deprecated use `completionEvents: 'onCommand:...'` */
125
>
readonly doneOn?: { command: string };
126
>
readonly when?: string;
127
>
}
128
>
129
>
export interface IWalkthrough {
130
>
readonly id: string;
131
>
readonly title: string;
132
>
readonly icon?: string;
133
>
readonly description: string;
134
>
readonly steps: IWalkthroughStep[];
135
>
readonly featuredFor: string[] | undefined;
136
>
readonly when?: string;
137
>
}
138
>
139
>
export interface IStartEntry {
140
>
readonly title: string;
141
>
readonly description: string;
142
>
readonly command: string;
143
>
readonly when?: string;
144
>
readonly category: 'file' | 'folder' | 'notebook';
145
>
}
146
>
147
>
export interface INotebookEntry {
148
>
readonly type: string;
149
>
readonly displayName: string;
150
>
}
151
>
152
>
export interface INotebookRendererContribution {
153
>
readonly id: string;
154
>
readonly displayName: string;
155
>
readonly mimeTypes: string[];
156
>
}
157
>
158
>
export interface IDebugVisualizationContribution {
159
>
readonly id: string;
160
>
readonly when: string;
161
>
}
162
>
163
>
export interface ITranslation {
164
>
id: string;
165
>
path: string;
166
>
}
167
>
168
>
export interface ILocalizationContribution {
169
>
languageId: string;
170
>
languageName?: string;
171
>
localizedLanguageName?: string;
172
>
translations: ITranslation[];
173
>
minimalTranslations?: { [key: string]: string };
174
>
}
175
>
176
>
export interface IChatParticipantContribution {
177
>
id: string;
178
>
name: string;
179
>
fullName: string;
180
>
description?: string;
181
>
isDefault?: boolean;
182
>
commands?: { name: string }[];
183
>
}
184
>
185
>
export interface IToolContribution {
186
>
name: string;
187
>
displayName: string;
188
>
modelDescription: string;
189
>
userDescription?: string;
190
>
}
191
>
192
>
export interface IToolSetContribution {
193
>
name: string;
194
>
referenceName: string;
195
>
description: string;
196
>
icon?: string;
197
>
tools: string[];
198
>
}
199
>
200
>
export interface IMcpCollectionContribution {
201
>
readonly id: string;
202
>
readonly label: string;
203
>
readonly when?: string;
204
>
}
205
>
206
>
export interface IChatFileContribution {
207
>
readonly path: string;
208
>
readonly name?: string;
209
>
readonly description?: string;
210
>
readonly when?: string;
211
>
readonly sessionTypes?: readonly string[];
212
>
}
213
>
214
>
export interface IExtensionContributions {
215
>
commands?: ICommand[];
216
>
configuration?: any;
217
>
configurationDefaults?: any;
218
>
debuggers?: IDebugger[];
219
>
grammars?: IGrammar[];
220
>
jsonValidation?: IJSONValidation[];
221
>
jsonValidationRegistry?: IJSONValidationRegistry[];
222
>
keybindings?: IKeyBinding[];
223
>
languages?: ILanguage[];
224
>
menus?: { [context: string]: IMenu[] };
225
>
snippets?: ISnippet[];
226
>
themes?: ITheme[];
227
>
iconThemes?: ITheme[];
228
>
productIconThemes?: ITheme[];
229
>
viewsContainers?: { [location: string]: IViewContainer[] };
230
>
views?: { [location: string]: IView[] };
231
>
colors?: IColor[];
232
>
localizations?: ILocalizationContribution[];
233
>
readonly customEditors?: readonly IWebviewEditor[];
234
>
readonly codeActions?: readonly ICodeActionContribution[];
235
>
authentication?: IAuthenticationContribution[];
236
>
walkthroughs?: IWalkthrough[];
237
>
startEntries?: IStartEntry[];
238
>
readonly notebooks?: INotebookEntry[];
239
>
readonly notebookRenderer?: INotebookRendererContribution[];
240
>
readonly debugVisualizers?: IDebugVisualizationContribution[];
241
>
readonly chatParticipants?: ReadonlyArray<IChatParticipantContribution>;
242
>
readonly chatPromptFiles?: ReadonlyArray<IChatFileContribution>;
243
>
readonly chatInstructions?: ReadonlyArray<IChatFileContribution>;
244
>
readonly chatAgents?: ReadonlyArray<IChatFileContribution>;
245
>
readonly chatSkills?: ReadonlyArray<IChatFileContribution>;
246
>
readonly chatPlugins?: ReadonlyArray<IChatFileContribution>;
247
>
readonly languageModelTools?: ReadonlyArray<IToolContribution>;
248
>
readonly languageModelToolSets?: ReadonlyArray<IToolSetContribution>;
249
>
readonly mcpServerDefinitionProviders?: ReadonlyArray<IMcpCollectionContribution>;
250
>
}
251
>
252
>
export interface IExtensionCapabilities {
253
>
readonly virtualWorkspaces?: ExtensionVirtualWorkspaceSupport;
254
>
readonly untrustedWorkspaces?: ExtensionUntrustedWorkspaceSupport;
255
>
}
256
>
257
>
258
>
export const ALL_EXTENSION_KINDS: readonly ExtensionKind[] = ['ui', 'workspace', 'web'];
259
>
260
>
export type LimitedWorkspaceSupportType = 'limited';
261
>
export type ExtensionUntrustedWorkspaceSupportType = boolean | LimitedWorkspaceSupportType;
262
>
export type ExtensionUntrustedWorkspaceSupport = { supported: true } | { supported: false; description: string } | { supported: LimitedWorkspaceSupportType; description: string; restrictedConfigurations?: string[] };
263
>
264
>
export type ExtensionVirtualWorkspaceSupportType = boolean | LimitedWorkspaceSupportType;
265
>
export type ExtensionVirtualWorkspaceSupport = boolean | { supported: true } | { supported: false | LimitedWorkspaceSupportType; description: string };
266
>
267
>
export function getWorkspaceSupportTypeMessage(supportType: ExtensionUntrustedWorkspaceSupport | ExtensionVirtualWorkspaceSupport | undefined): string | undefined {
268
if (typeof supportType === 'object' && supportType !== null) {
269
if (supportType.supported !== true) {
270
return supportType.description;
271
}
272
}
273
return undefined;
274
}
276
>
277
>
export interface IExtensionIdentifier {
278
>
id: string;
279
>
uuid?: string;
280
>
}
281
>
282
>
export const EXTENSION_CATEGORIES = [
283
>
'AI',
284
>
'Azure',
285
>
'Chat',
286
>
'Data Science',
287
>
'Debuggers',
288
>
'Extension Packs',
289
>
'Education',
290
>
'Formatters',
291
>
'Keymaps',
292
>
'Language Packs',
293
>
'Linters',
294
>
'Machine Learning',
295
>
'Notebooks',
296
>
'Programming Languages',
297
>
'SCM Providers',
298
>
'Snippets',
299
>
'Testing',
300
>
'Themes',
301
>
'Visualization',
302
>
'Other',
303
>
];
304
>
305
>
export interface IRelaxedExtensionManifest {
306
>
name: string;
307
>
displayName?: string;
308
>
publisher: string;
309
>
version: string;
310
>
engines: { readonly vscode: string };
311
>
description?: string;
312
>
main?: string;
313
>
type?: string;
314
>
browser?: string;
315
>
preview?: boolean;
316
>
// For now this only supports pointing to l10n bundle files
317
>
// but it will be used for package.l10n.json files in the future
318
>
l10n?: string;
319
>
icon?: string;
320
>
categories?: string[];
321
>
keywords?: string[];
322
>
activationEvents?: readonly string[];
323
>
extensionDependencies?: string[];
324
>
extensionAffinity?: string[];
325
>
extensionPack?: string[];
326
>
extensionKind?: ExtensionKind | ExtensionKind[];
327
>
contributes?: IExtensionContributions;
328
>
repository?: { url: string };
329
>
bugs?: { url: string };
330
>
originalEnabledApiProposals?: readonly string[];
331
>
enabledApiProposals?: readonly string[];
332
>
api?: string;
333
>
scripts?: { [key: string]: string };
334
>
capabilities?: IExtensionCapabilities;
335
>
}
336
>
337
>
export type IExtensionManifest = Readonly<IRelaxedExtensionManifest>;
338
>
339
>
export const enum ExtensionType {
340
>
System,
341
>
User
342
>
}
343
>
344
>
export const enum TargetPlatform {
345
>
WIN32_X64 = 'win32-x64',
346
>
WIN32_ARM64 = 'win32-arm64',
347
>
348
>
LINUX_X64 = 'linux-x64',
349
>
LINUX_ARM64 = 'linux-arm64',
350
>
LINUX_ARMHF = 'linux-armhf',
351
>
352
>
ALPINE_X64 = 'alpine-x64',
353
>
ALPINE_ARM64 = 'alpine-arm64',
354
>
355
>
DARWIN_X64 = 'darwin-x64',
356
>
DARWIN_ARM64 = 'darwin-arm64',
357
>
358
>
WEB = 'web',
359
>
360
>
UNIVERSAL = 'universal',
361
>
UNKNOWN = 'unknown',
362
>
UNDEFINED = 'undefined',
363
>
}
364
>
365
>
export interface IExtension {
366
>
readonly type: ExtensionType;
367
>
readonly isBuiltin: boolean;
368
>
readonly identifier: IExtensionIdentifier;
369
>
readonly manifest: IExtensionManifest;
370
>
readonly location: URI;
371
>
readonly targetPlatform: TargetPlatform;
372
>
readonly publisherDisplayName?: string;
373
>
readonly readmeUrl?: URI;
374
>
readonly changelogUrl?: URI;
375
>
readonly isValid: boolean;
376
>
readonly validations: readonly [Severity, string][];
377
>
readonly preRelease: boolean;
378
>
}
379
>
380
>
/**
381
>
* **!Do not construct directly!**
382
>
*
383
>
* **!Only static methods because it gets serialized!**
384
>
*
385
>
* This represents the "canonical" version for an extension identifier. Extension ids
386
>
* have to be case-insensitive (due to the marketplace), but we must ensure case
387
>
* preservation because the extension API is already public at this time.
388
>
*
389
>
* For example, given an extension with the publisher `"Hello"` and the name `"World"`,
390
>
* its canonical extension identifier is `"Hello.World"`. This extension could be
391
>
* referenced in some other extension's dependencies using the string `"hello.world"`.
392
>
*
393
>
* To make matters more complicated, an extension can optionally have an UUID. When two
394
>
* extensions have the same UUID, they are considered equal even if their identifier is different.
395
>
*/
396
>
export class ExtensionIdentifier {
397
>
public readonly value: string;
398
>
399
>
/**
400
>
* Do not use directly. This is public to avoid mangling and thus
401
>
* allow compatibility between running from source and a built version.
402
>
*/
403
>
readonly _lower: string;
404
>
405
>
constructor(value: string) {
407
>
this._lower = value.toLowerCase();
408
>
}
410
>
public static equals(a: ExtensionIdentifier | string | null | undefined, b: ExtensionIdentifier | string | null | undefined) {
412
return (typeof b === 'undefined' || b === null);
413
}
415
return false;
416
}
419
>
// so we have to use the string comparison which ignores case.
420
>
const aValue = (typeof a === 'string' ? a : a.value);
421
>
const bValue = (typeof b === 'string' ? b : b.value);
422
>
return strings.equalsIgnoreCase(aValue, bValue);
423
>
}
425
>
// Now we know both arguments are ExtensionIdentifier
426
>
return (a._lower === b._lower);
429
>
/**
430
>
* Gives the value by which to index (for equality).
431
>
*/
432
>
public static toKey(id: ExtensionIdentifier | string): string {
435
>
}
439
>
440
>
export class ExtensionIdentifierSet {
441
>
442
>
private readonly _set = new Set<string>();
443
>
444
>
public get size(): number {
445
>
return this._set.size;
446
>
}
447
>
448
>
constructor(iterable?: Iterable<ExtensionIdentifier | string>) {
450
>
for (const value of iterable) {
451
>
this.add(value);
452
>
}
453
>
}
454
>
}
456
>
public add(id: ExtensionIdentifier | string): void {
458
>
}
460
>
public delete(extensionId: ExtensionIdentifier): boolean {
461
return this._set.delete(ExtensionIdentifier.toKey(extensionId));
462
}
464
>
public has(id: ExtensionIdentifier | string): boolean {
466
>
}
468
>
469
>
export class ExtensionIdentifierMap<T> {
471
>
private readonly _map = new Map<string, T>();
473
>
public clear(): void {
474
this._map.clear();
475
}
477
>
public delete(id: ExtensionIdentifier | string): void {
479
>
}
481
>
public get(id: ExtensionIdentifier | string): T | undefined {
483
>
}
485
>
public has(id: ExtensionIdentifier | string): boolean {
487
>
}
489
>
public set(id: ExtensionIdentifier | string, value: T): void {
491
>
}
493
>
public values(): IterableIterator<T> {
495
>
}
497
>
forEach(callbackfn: (value: T, key: string, map: Map<string, T>) => void): void {
498
this._map.forEach(callbackfn);
499
}
501
>
[Symbol.iterator](): IterableIterator<[string, T]> {
503
>
}
505
>
506
>
/**
507
>
* An error that is clearly from an extension, identified by the `ExtensionIdentifier`
508
>
*/
509
>
export class ExtensionError extends Error {
510
>
511
>
readonly extension: ExtensionIdentifier;
512
>
513
>
constructor(extensionIdentifier: ExtensionIdentifier, cause: Error, message?: string) {
514
const detail = message && cause?.message ? `${message}: ${cause.message}` : (message ?? cause?.message);
515
super(`Error in extension ${ExtensionIdentifier.toKey(extensionIdentifier)}: ${detail}`, { cause });
516
this.name = 'ExtensionError';
517
this.extension = extensionIdentifier;
518
// Adopt the underlying cause's stack so error telemetry buckets by the real
519
// failure site inside the extension instead of the generic event-dispatch
520
// frames. Extension attribution relies on `this.extension`, not this stack.
521
if (cause?.stack) {
522
this.stack = cause.stack;
523
}
524
}
526
>
527
>
export interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest {
528
>
id?: string;
529
>
identifier: ExtensionIdentifier;
530
>
uuid?: string;
531
>
publisherDisplayName?: string;
532
>
targetPlatform: TargetPlatform;
533
>
isBuiltin: boolean;
534
>
isUserBuiltin: boolean;
535
>
isUnderDevelopment: boolean;
536
>
extensionLocation: URI;
537
>
preRelease: boolean;
538
>
}
539
>
540
>
export type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
541
>
542
>
export function isApplicationScopedExtension(manifest: IExtensionManifest): boolean {
543
return isLanguagePackExtension(manifest);
544
}
546
>
export function isLanguagePackExtension(manifest: IExtensionManifest): boolean {
547
return manifest.contributes && manifest.contributes.localizations ? manifest.contributes.localizations.length > 0 : false;
548
}
550
>
export function isAuthenticationProviderExtension(manifest: IExtensionManifest): boolean {
551
return manifest.contributes && manifest.contributes.authentication ? manifest.contributes.authentication.length > 0 : false;
552
}
554
>
export function isResolverExtension(manifest: IExtensionManifest, remoteAuthority: string | undefined): boolean {
555
if (remoteAuthority) {
556
const activationEvent = `onResolveRemoteAuthority:${getRemoteName(remoteAuthority)}`;
557
return !!manifest.activationEvents?.includes(activationEvent);
558
}
559
return false;
560
}
562
>
export function parseEnabledApiProposalNames(enabledApiProposals: string[]): string[] {
564
>
}
566
>
export const IBuiltinExtensionsScannerService = createDecorator<IBuiltinExtensionsScannerService>('IBuiltinExtensionsScannerService');
567
>
export interface IBuiltinExtensionsScannerService {
568
>
readonly _serviceBrand: undefined;
569
>
scanBuiltinExtensions(): Promise<IExtension[]>;
570
>
}