src/vs/workbench/contrib/extensions/common/extensions.ts

283 LOC · 259 covered · 24 uncovered · 4 ranges · 188 concepts · 1 introducers · 178 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
  >
  /*---------------------------------------------------------------------------------------------
  
pluginMarketplaceService.ts ×39

  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 { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
  
  7
  >
  import { Event } from '../../../../base/common/event.js';
  
  8
  >
  import { IPager } from '../../../../base/common/paging.js';
  
  9
  >
  import { IQueryOptions, ILocalExtension, IGalleryExtension, IExtensionIdentifier, IExtensionInfo, IExtensionQueryOptions, IDeprecationInfo, InstallExtensionResult, InstallOptions } from '../../../../platform/extensionManagement/common/extensionManagement.js';
  
  10
  >
  import { EnablementState, IExtensionManagementServer, IResourceExtension } from '../../../services/extensionManagement/common/extensionManagement.js';
  
  11
  >
  import { CancellationToken } from '../../../../base/common/cancellation.js';
  
  12
  >
  import { Disposable, IDisposable } from '../../../../base/common/lifecycle.js';
  
  13
  >
  import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
  
  14
  >
  import { IExtensionManifest, ExtensionType } from '../../../../platform/extensions/common/extensions.js';
  
  15
  >
  import { URI } from '../../../../base/common/uri.js';
  
  16
  >
  import { IView, IViewPaneContainer } from '../../../common/views.js';
  
  17
  >
  import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
  
  18
  >
  import { IExtensionsStatus as IExtensionRuntimeStatus } from '../../../services/extensions/common/extensions.js';
  
  19
  >
  import { IExtensionEditorOptions } from './extensionsInput.js';
  
  20
  >
  import { MenuId } from '../../../../platform/actions/common/actions.js';
  
  21
  >
  import { ProgressLocation } from '../../../../platform/progress/common/progress.js';
  
  22
  >
  import { Severity } from '../../../../platform/notification/common/notification.js';
  
  23
  >
  import { IMarkdownString } from '../../../../base/common/htmlContent.js';
  
  24
  >
  import { localize2 } from '../../../../nls.js';
  
  25
  >
  import { ExtensionGalleryManifestStatus } from '../../../../platform/extensionManagement/common/extensionGalleryManifest.js';
  
  26
  >
  
  27
  >
  export const VIEWLET_ID = 'workbench.view.extensions';
  
  28
  >
  export const EXTENSIONS_CATEGORY = localize2('extensions', "Extensions");
  
  29
  >
  
  30
  >
  export interface IExtensionsViewPaneContainer extends IViewPaneContainer {
  
  31
  >
  	readonly searchValue: string | undefined;
  
  32
  >
  	search(text: string): void;
  
  33
  >
  	refresh(): Promise<void>;
  
  34
  >
  }
  
  35
  >
  
  36
  >
  export interface IWorkspaceRecommendedExtensionsView extends IView {
  
  37
  >
  	installWorkspaceRecommendations(): Promise<void>;
  
  38
  >
  }
  
  39
  >
  
  40
  >
  export const enum ExtensionState {
  
  41
  >
  	Installing,
  
  42
  >
  	Installed,
  
  43
  >
  	Uninstalling,
  
  44
  >
  	Uninstalled
  
  45
  >
  }
  
  46
  >
  
  47
  >
  export const enum ExtensionRuntimeActionType {
  
  48
  >
  	ReloadWindow = 'reloadWindow',
  
  49
  >
  	RestartExtensions = 'restartExtensions',
  
  50
  >
  	DownloadUpdate = 'downloadUpdate',
  
  51
  >
  	ApplyUpdate = 'applyUpdate',
  
  52
  >
  	QuitAndInstall = 'quitAndInstall',
  
  53
  >
  }
  
  54
  >
  
  55
  >
  export type ExtensionRuntimeState = { action: ExtensionRuntimeActionType; reason: string };
  
  56
  >
  
  57
  >
  export interface IExtension {
  
  58
  >
  	readonly type: ExtensionType;
  
  59
  >
  	readonly isBuiltin: boolean;
  
  60
  >
  	readonly isWorkspaceScoped: boolean;
  
  61
  >
  	readonly state: ExtensionState;
  
  62
  >
  	readonly name: string;
  
  63
  >
  	readonly displayName: string;
  
  64
  >
  	readonly identifier: IExtensionIdentifier;
  
  65
  >
  	readonly publisher: string;
  
  66
  >
  	readonly publisherDisplayName: string;
  
  67
  >
  	readonly publisherUrl?: URI;
  
  68
  >
  	readonly publisherDomain?: { link: string; verified: boolean };
  
  69
  >
  	readonly publisherSponsorLink?: URI;
  
  70
  >
  	readonly pinned: boolean;
  
  71
  >
  	readonly version: string;
  
  72
  >
  	readonly private: boolean;
  
  73
  >
  	readonly latestVersion: string;
  
  74
  >
  	readonly preRelease: boolean;
  
  75
  >
  	readonly isPreReleaseVersion: boolean;
  
  76
  >
  	readonly hasPreReleaseVersion: boolean;
  
  77
  >
  	readonly hasReleaseVersion: boolean;
  
  78
  >
  	readonly description: string;
  
  79
  >
  	readonly url?: string;
  
  80
  >
  	readonly repository?: string;
  
  81
  >
  	readonly supportUrl?: string;
  
  82
  >
  	readonly iconUrl?: string;
  
  83
  >
  	readonly iconUrlFallback?: string;
  
  84
  >
  	readonly licenseUrl?: string;
  
  85
  >
  	readonly installCount?: number;
  
  86
  >
  	readonly rating?: number;
  
  87
  >
  	readonly ratingCount?: number;
  
  88
  >
  	readonly ratingUrl?: string;
  
  89
  >
  	readonly outdated: boolean;
  
  90
  >
  	readonly outdatedTargetPlatform: boolean;
  
  91
  >
  	readonly runtimeState: ExtensionRuntimeState | undefined;
  
  92
  >
  	readonly enablementState: EnablementState;
  
  93
  >
  	readonly tags: readonly string[];
  
  94
  >
  	readonly categories: readonly string[];
  
  95
  >
  	readonly dependencies: string[];
  
  96
  >
  	readonly extensionPack: string[];
  
  97
  >
  	readonly telemetryData: any;
  
  98
  >
  	readonly preview: boolean;
  
  99
  >
  	getManifest(token: CancellationToken): Promise<IExtensionManifest | null>;
  
  100
  >
  	hasReadme(): boolean;
  
  101
  >
  	getReadme(token: CancellationToken): Promise<string>;
  
  102
  >
  	hasChangelog(): boolean;
  
  103
  >
  	getChangelog(token: CancellationToken): Promise<string>;
  
  104
  >
  	readonly server?: IExtensionManagementServer;
  
  105
  >
  	readonly local?: ILocalExtension;
  
  106
  >
  	gallery?: IGalleryExtension;
  
  107
  >
  	readonly resourceExtension?: IResourceExtension;
  
  108
  >
  	readonly isMalicious: boolean | undefined;
  
  109
  >
  	readonly maliciousInfoLink: string | undefined;
  
  110
  >
  	readonly deprecationInfo?: IDeprecationInfo;
  
  111
  >
  	readonly missingFromGallery?: boolean;
  
  112
  >
  }
  
  113
  >
  
  114
  >
  export const IExtensionsWorkbenchService = createDecorator<IExtensionsWorkbenchService>('extensionsWorkbenchService');
  
  115
  >
  
  116
  >
  export interface InstallExtensionOptions extends InstallOptions {
  
  117
  >
  	version?: string;
  
  118
  >
  	justification?: string | { reason: string; action: string };
  
  119
  >
  	enable?: boolean;
  
  120
  >
  	installEverywhere?: boolean;
  
  121
  >
  }
  
  122
  >
  
  123
  >
  export interface IExtensionsNotification {
  
  124
  >
  	readonly message: string | IMarkdownString;
  
  125
  >
  	readonly severity: Severity;
  
  126
  >
  	readonly extensions: IExtension[];
  
  127
  >
  	readonly query?: string;
  
  128
  >
  	readonly action?: { readonly label: string; run(): void };
  
  129
  >
  	dismiss?(): void;
  
  130
  >
  }
  
  131
  >
  
  132
  >
  export interface IExtensionsWorkbenchService {
  
  133
  >
  	readonly _serviceBrand: undefined;
  
  134
  >
  	readonly onChange: Event<IExtension | undefined>;
  
  135
  >
  	readonly onReset: Event<void>;
  
  136
  >
  	readonly local: IExtension[];
  
  137
  >
  	readonly installed: IExtension[];
  
  138
  >
  	readonly outdated: IExtension[];
  
  139
  >
  	readonly whenInitialized: Promise<void>;
  
  140
  >
  	queryLocal(server?: IExtensionManagementServer): Promise<IExtension[]>;
  
  141
  >
  	queryGallery(token: CancellationToken): Promise<IPager<IExtension>>;
  
  142
  >
  	queryGallery(options: IQueryOptions, token: CancellationToken): Promise<IPager<IExtension>>;
  
  143
  >
  	getExtensions(extensionInfos: IExtensionInfo[], token: CancellationToken): Promise<IExtension[]>;
  
  144
  >
  	getExtensions(extensionInfos: IExtensionInfo[], options: IExtensionQueryOptions, token: CancellationToken): Promise<IExtension[]>;
  
  145
  >
  	getResourceExtensions(locations: URI[], isWorkspaceScoped: boolean): Promise<IExtension[]>;
  
  146
  >
  	canInstall(extension: IExtension): Promise<true | IMarkdownString>;
  
  147
  >
  	install(id: string, installOptions?: InstallExtensionOptions, progressLocation?: ProgressLocation | string): Promise<IExtension>;
  
  148
  >
  	install(vsix: URI, installOptions?: InstallExtensionOptions, progressLocation?: ProgressLocation | string): Promise<IExtension>;
  
  149
  >
  	install(extension: IExtension, installOptions?: InstallExtensionOptions, progressLocation?: ProgressLocation | string): Promise<IExtension>;
  
  150
  >
  	installInServer(extension: IExtension, server: IExtensionManagementServer, installOptions?: InstallOptions): Promise<void>;
  
  151
  >
  	downloadVSIX(extension: string, versionKind: 'prerelease' | 'release' | 'any'): Promise<void>;
  
  152
  >
  	uninstall(extension: IExtension): Promise<void>;
  
  153
  >
  	togglePreRelease(extension: IExtension): Promise<void>;
  
  154
  >
  	canSetLanguage(extension: IExtension): boolean;
  
  155
  >
  	setLanguage(extension: IExtension): Promise<void>;
  
  156
  >
  	setEnablement(extensions: IExtension | IExtension[], enablementState: EnablementState): Promise<void>;
  
  157
  >
  	isAutoUpdateEnabledFor(extensionOrPublisher: IExtension | string): boolean;
  
  158
  >
  	updateAutoUpdateEnablementFor(extensionOrPublisher: IExtension | string, enable: boolean): Promise<void>;
  
  159
  >
  	shouldRequireConsentToUpdate(extension: IExtension): Promise<string | undefined>;
  
  160
  >
  	updateAutoUpdateForAllExtensions(value: boolean): Promise<void>;
  
  161
  >
  	open(extension: IExtension | string, options?: IExtensionEditorOptions): Promise<void>;
  
  162
  >
  	openSearch(searchValue: string, focus?: boolean): Promise<void>;
  
  163
  >
  	getAutoUpdateValue(): AutoUpdateConfigurationValue;
  
  164
  >
  	isAutoUpdateDelayed(extension: IExtension): boolean;
  
  165
  >
  	getAutoUpdateDelayRemaining(extension: IExtension): number;
  
  166
  >
  	getAutoUpdateDelay(): number;
  
  167
  >
  	checkForUpdates(): Promise<void>;
  
  168
  >
  	getExtensionRuntimeStatus(extension: IExtension): IExtensionRuntimeStatus | undefined;
  
  169
  >
  	updateAll(): Promise<InstallExtensionResult[]>;
  
  170
  >
  	updateRunningExtensions(message?: string): Promise<void>;
  
  171
  >
  
  172
  >
  	readonly onDidChangeExtensionsNotification: Event<IExtensionsNotification | undefined>;
  
  173
  >
  	getExtensionsNotification(): IExtensionsNotification | undefined;
  
  174
  >
  
  175
  >
  	// Sync APIs
  
  176
  >
  	isExtensionIgnoredToSync(extension: IExtension): boolean;
  
  177
  >
  	toggleExtensionIgnoredToSync(extension: IExtension): Promise<void>;
  
  178
  >
  	toggleApplyExtensionToAllProfiles(extension: IExtension): Promise<void>;
  
  179
  >
  }
  
  180
  >
  
  181
  >
  export const enum ExtensionEditorTab {
  
  182
  >
  	Readme = 'readme',
  
  183
  >
  	Features = 'features',
  
  184
  >
  	Changelog = 'changelog',
  
  185
  >
  	Dependencies = 'dependencies',
  
  186
  >
  	ExtensionPack = 'extensionPack',
  
  187
  >
  }
  
  188
  >
  
  189
  >
  export const ConfigurationKey = 'extensions';
  
  190
  >
  export const AutoUpdateConfigurationKey = 'extensions.autoUpdate';
  
  191
  >
  export const AutoUpdateDelayConfigurationKey = 'extensions.autoUpdateDelay';
  
  192
  >
  export const AutoCheckUpdatesConfigurationKey = 'extensions.autoCheckUpdates';
  
  193
  >
  export const CloseExtensionDetailsOnViewChangeKey = 'extensions.closeExtensionDetailsOnViewChange';
  
  194
  >
  export const AutoRestartConfigurationKey = 'extensions.autoRestart';
  
  195
  >
  
  196
  >
  export type AutoUpdateConfigurationValue = 'on' | 'off';
  
  197
  >
  
  198
  >
  export interface IExtensionsConfiguration {
  
  199
  >
  	autoUpdate: AutoUpdateConfigurationValue;
  
  200
  >
  	autoUpdateDelay: number;
  
  201
  >
  	autoCheckUpdates: boolean;
  
  202
  >
  	ignoreRecommendations: boolean;
  
  203
  >
  	closeExtensionDetailsOnViewChange: boolean;
  
  204
  >
  }
  
  205
  >
  
  206
  >
  export interface IExtensionContainer extends IDisposable {
  
  207
  >
  	extension: IExtension | null;
  
  208
  >
  	updateWhenCounterExtensionChanges?: boolean;
  
  209
  >
  	update(): void;
  
  210
  >
  }
  
  211
  >
  
  212
  >
  export interface IExtensionsViewState {
  
  213
  >
  	readonly onFocus: Event<IExtension>;
  
  214
  >
  	readonly onBlur: Event<IExtension>;
  
  215
  >
  	filters: {
  
  216
  >
  		featureId?: string;
  
  217
  >
  	};
  
  218
  >
  }
  
  219
  >
  
  220
  >
  export class ExtensionContainers extends Disposable {
  
  221
  >
  
  222
  >
  	constructor(
  
  223
  
  		private readonly containers: IExtensionContainer[],
  
  224
  
  		@IExtensionsWorkbenchService extensionsWorkbenchService: IExtensionsWorkbenchService
  
  225
  
  	) {
  
  226
  
  		super();
  
  227
  
  		this._register(extensionsWorkbenchService.onChange(this.update, this));
  
  228
  
  	}
  
  229
  >
  
pluginMarketplaceService.ts ×39

  230
  >
  	set extension(extension: IExtension) {
  
  231
  
  		this.containers.forEach(c => c.extension = extension);
  
  232
  
  	}
  
  233
  >
  
pluginMarketplaceService.ts ×39

  234
  >
  	private update(extension: IExtension | undefined): void {
  
  235
  
  		for (const container of this.containers) {
  
  236
  
  			if (extension && container.extension) {
  
  237
  
  				if (areSameExtensions(container.extension.identifier, extension.identifier)) {
  
  238
  
  					if (container.extension.server && extension.server && container.extension.server !== extension.server) {
  
  239
  
  						if (container.updateWhenCounterExtensionChanges) {
  
  240
  
  							container.update();
  
  241
  
  						}
  
  242
  
  					} else {
  
  243
  
  						container.extension = extension;
  
  244
  
  					}
  
  245
  
  				}
  
  246
  
  			} else {
  
  247
  
  				container.update();
  
  248
  
  			}
  
  249
  
  		}
  
  250
  
  	}
  
  251
  >
  }
  
pluginMarketplaceService.ts ×39

  252
  >
  
  253
  >
  export const WORKSPACE_RECOMMENDATIONS_VIEW_ID = 'workbench.views.extensions.workspaceRecommendations';
  
  254
  >
  export const OUTDATED_EXTENSIONS_VIEW_ID = 'workbench.views.extensions.searchOutdated';
  
  255
  >
  export const TOGGLE_IGNORE_EXTENSION_ACTION_ID = 'workbench.extensions.action.toggleIgnoreExtension';
  
  256
  >
  export const SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID = 'workbench.extensions.action.installVSIX';
  
  257
  >
  export const INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID = 'workbench.extensions.command.installFromVSIX';
  
  258
  >
  
  259
  >
  export const LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID = 'workbench.extensions.action.listWorkspaceUnsupportedExtensions';
  
  260
  >
  
  261
  >
  // Context Keys
  
  262
  >
  export const DefaultViewsContext = new RawContextKey<boolean>('defaultExtensionViews', true);
  
  263
  >
  export const HasOutdatedExtensionsContext = new RawContextKey<boolean>('hasOutdatedExtensions', false);
  
  264
  >
  export const CONTEXT_HAS_GALLERY = new RawContextKey<boolean>('hasGallery', false);
  
  265
  >
  export const CONTEXT_EXTENSIONS_GALLERY_STATUS = new RawContextKey<string>('extensionsGalleryStatus', ExtensionGalleryManifestStatus.Unavailable);
  
  266
  >
  export const ExtensionResultsListFocused = new RawContextKey<boolean>('extensionResultListFocused ', true);
  
  267
  >
  export const SearchMcpServersContext = new RawContextKey<boolean>('searchMcpServers', false);
  
  268
  >
  export const SearchAgentPluginsContext = new RawContextKey<boolean>('searchAgentPlugins', false);
  
  269
  >
  
  270
  >
  // Context Menu Groups
  
  271
  >
  export const THEME_ACTIONS_GROUP = '_theme_';
  
  272
  >
  export const INSTALL_ACTIONS_GROUP = '0_install';
  
  273
  >
  export const UPDATE_ACTIONS_GROUP = '0_update';
  
  274
  >
  
  275
  >
  export const extensionsSearchActionsMenu = new MenuId('extensionsSearchActionsMenu');
  
  276
  >
  export const extensionsFilterSubMenu = new MenuId('extensionsFilterSubMenu');
  
  277
  >
  
  278
  >
  export interface IExtensionArg {
  
  279
  >
  	id: string;
  
  280
  >
  	version: string;
  
  281
  >
  	location: URI | undefined;
  
  282
  >
  	galleryLink: string | undefined;
  
  283
  >
  }