extensions.ts ×24

Frontier kind: Code frontier

unlabeled · c_8da727e4a8ce

2063 tests · 5909 LOC · 30 files · introduces 0 tests · 483 LOC · 1 file

Introduces — evidence that enters the hierarchy at this concept

Code
24 ranges483 lines · 1 files
Tests
0 tests

Contains — complete concept membership

All code (extent)
771 ranges5909 lines · 30 files · Browse complete extent
All tests (intent)
2063 testsBrowse complete intent

Neighbourhood graph

The orange circle is the focus. Violet and green circles are every ancestor and descendant, broader and narrower, at any distance; blue squares and pink diamonds are the introduced files and exact introduced tests of every visible concept, not only the focus's. Arrows point from broader to narrower concepts and bridge only concepts omitted from this view. Undirected links show source or test introduction. Concept and file size follows LOC; exact test nodes use test-count units.

Introduced files, introduced tests, and structurally relevant concept specialization

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 native relationship evidence on this page.

Graph controls are ready.

Interactive rendering requires JavaScript and WebGL. Use the native relationship evidence on this page while the interactive map is unavailable.

Native relationship evidence

Every exact file and test below is linked only from the concept that introduces it.

Introduced tests

Every collected test enters the hierarchy at exactly one concept.

No tests are introduced at this concept. Its intent tests are introduced by other concepts.

Introduced code

Every collected source range enters the hierarchy at exactly one concept.

1 file ranked by introduced lines: 483 introduced LOC across 24 ranges. Expand a file to inspect source; the > gutter marks introduced lines.

src/vs/platform/extensions/common/extensions.ts 483 introduced LOC · 24 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- extensions.ts
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) {
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) {
406 this.value = value;
407 this._lower = value.toLowerCase();
408 }
410 > public static equals(a: ExtensionIdentifier | string | null | undefined, b: ExtensionIdentifier | string | null | undefined) {
411 if (typeof a === 'undefined' || a === null) {
412 return (typeof b === 'undefined' || b === null);
426 return (a._lower === b._lower);
427 }
429 > /**
430 > * Gives the value by which to index (for equality).
431 > */
432 > public static toKey(id: ExtensionIdentifier | string): string {
433 if (typeof id === 'string') {
434 return id.toLowerCase();
436 return id._lower;
437 }
438 > } extensions.ts
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>) {
449 if (iterable) {
450 for (const value of iterable) {
453 }
454 }
456 > public add(id: ExtensionIdentifier | string): void {
457 this._set.add(ExtensionIdentifier.toKey(id));
458 }
460 > public delete(extensionId: ExtensionIdentifier): boolean {
461 return this._set.delete(ExtensionIdentifier.toKey(extensionId));
462 }
464 > public has(id: ExtensionIdentifier | string): boolean {
465 return this._set.has(ExtensionIdentifier.toKey(id));
466 }
467 > } extensions.ts
468 >
469 > export class ExtensionIdentifierMap<T> {
470
471 private readonly _map = new Map<string, T>();
473 > public clear(): void {
474 this._map.clear();
475 }
477 > public delete(id: ExtensionIdentifier | string): void {
478 this._map.delete(ExtensionIdentifier.toKey(id));
479 }
481 > public get(id: ExtensionIdentifier | string): T | undefined {
482 return this._map.get(ExtensionIdentifier.toKey(id));
483 }
485 > public has(id: ExtensionIdentifier | string): boolean {
486 return this._map.has(ExtensionIdentifier.toKey(id));
487 }
489 > public set(id: ExtensionIdentifier | string, value: T): void {
490 this._map.set(ExtensionIdentifier.toKey(id), value);
491 }
493 > public values(): IterableIterator<T> {
494 return this._map.values();
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]> {
502 return this._map[Symbol.iterator]();
503 }
504 > } extensions.ts
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 });
523 }
524 }
525 > } extensions.ts
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)}`;
559 return false;
560 }
562 > export function parseEnabledApiProposalNames(enabledApiProposals: string[]): string[] {
563 return enabledApiProposals.map(proposal => proposal.split('@')[0]);
564 }
566 > export const IBuiltinExtensionsScannerService = createDecorator<IBuiltinExtensionsScannerService>('IBuiltinExtensionsScannerService');
567 > export interface IBuiltinExtensionsScannerService {
568 > readonly _serviceBrand: undefined;
569 > scanBuiltinExtensions(): Promise<IExtension[]>;
570 > }