@codingame/monaco-vscode-api 3.2.3 → 4.0.0

package/vscode/src/vs/workbench/services/authentication/browser/authenticationUsageService.js

@@ -0,0 +1,50 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+const IAuthenticationUsageService = ( createDecorator('IAuthenticationUsageService'));
+let AuthenticationUsageService = class AuthenticationUsageService {
+    constructor(_storageService) {
+        this._storageService = _storageService;
+    }
+    readAccountUsages(providerId, accountName) {
+        const accountKey = `${providerId}-${accountName}-usages`;
+        const storedUsages = this._storageService.get(accountKey, -1 );
+        let usages = [];
+        if (storedUsages) {
+            try {
+                usages = JSON.parse(storedUsages);
+            }
+            catch (e) {
+            }
+        }
+        return usages;
+    }
+    removeAccountUsage(providerId, accountName) {
+        const accountKey = `${providerId}-${accountName}-usages`;
+        this._storageService.remove(accountKey, -1 );
+    }
+    addAccountUsage(providerId, accountName, extensionId, extensionName) {
+        const accountKey = `${providerId}-${accountName}-usages`;
+        const usages = this.readAccountUsages(providerId, accountName);
+        const existingUsageIndex = usages.findIndex(usage => usage.extensionId === extensionId);
+        if (existingUsageIndex > -1) {
+            usages.splice(existingUsageIndex, 1, {
+                extensionId,
+                extensionName,
+                lastUsed: Date.now()
+            });
+        }
+        else {
+            usages.push({
+                extensionId,
+                extensionName,
+                lastUsed: Date.now()
+            });
+        }
+        this._storageService.store(accountKey, JSON.stringify(usages), -1 , 1 );
+    }
+};
+AuthenticationUsageService = ( __decorate([
+    ( __param(0, IStorageService))
+], AuthenticationUsageService));
+export { AuthenticationUsageService, IAuthenticationUsageService };

package/vscode/src/vs/workbench/services/authentication/common/authentication.js

@@ -1,4 +1,5 @@
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 const INTERNAL_AUTH_PROVIDER_PREFIX = '__';
 const IAuthenticationService = ( createDecorator('IAuthenticationService'));
-export { IAuthenticationService, INTERNAL_AUTH_PROVIDER_PREFIX };
+const IAuthenticationExtensionsService = ( createDecorator('IAuthenticationExtensionsService'));
+export { IAuthenticationExtensionsService, IAuthenticationService, INTERNAL_AUTH_PROVIDER_PREFIX };

package/vscode/src/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService.js

@@ -11,18 +11,19 @@ import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { isWeb } from '../../../../base/common/platform.js';
 import { WindowMinimumSize } from '../../../../platform/window/common/window.js';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import Severity from '../../../../base/common/severity.js';
+import Severity$1 from '../../../../base/common/severity.js';
 import { BaseWindow } from '../../../browser/window.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
 import { Barrier } from '../../../../base/common/async.js';
 import { IHostService } from '../../host/browser/host.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
 import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 var BrowserAuxiliaryWindowService_1;
 const IAuxiliaryWindowService = ( createDecorator('auxiliaryWindowService'));
 let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
-    constructor(window, container, stylesHaveLoaded, configurationService, hostService) {
-        super(window, undefined, hostService);
+    constructor(window, container, stylesHaveLoaded, configurationService, hostService, environmentService) {
+        super(window, undefined, hostService, environmentService);
         this.window = window;
         this.container = container;
         this.configurationService = configurationService;
@@ -36,7 +37,7 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
         this.onUnload = this._onUnload.event;
         this._onWillDispose = this._register(( new Emitter()));
         this.onWillDispose = this._onWillDispose.event;
-        this.whenStylesHaveLoaded = stylesHaveLoaded.wait().then(() => { });
+        this.whenStylesHaveLoaded = stylesHaveLoaded.wait().then(() => undefined);
         this.registerListeners();
     }
     registerListeners() {
@@ -59,14 +60,28 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
         }
     }
     handleBeforeUnload(e) {
-        this._onBeforeUnload.fire();
+        let veto;
+        this._onBeforeUnload.fire({
+            veto(reason) {
+                if (reason) {
+                    veto = reason;
+                }
+            }
+        });
+        if (veto) {
+            this.handleVetoBeforeClose(e, veto);
+            return;
+        }
         const confirmBeforeCloseSetting = this.configurationService.getValue('window.confirmBeforeClose');
         const confirmBeforeClose = confirmBeforeCloseSetting === 'always' || (confirmBeforeCloseSetting === 'keyboardOnly' && ModifierKeyEmitter.getInstance().isModifierPressed);
         if (confirmBeforeClose) {
             this.confirmBeforeClose(e);
         }
     }
-    confirmBeforeClose(e) {
+    handleVetoBeforeClose(e, reason) {
+        this.preventUnload(e);
+    }
+    preventUnload(e) {
         e.preventDefault();
         e.returnValue = ( localizeWithPath(
             'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
@@ -74,6 +89,9 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
             "Changes that you made may not be saved. Please check press 'Cancel' and try again."
         ));
     }
+    confirmBeforeClose(e) {
+        this.preventUnload(e);
+    }
     handleUnload() {
         this._onUnload.fire();
     }
@@ -92,19 +110,21 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
 };
 AuxiliaryWindow = ( __decorate([
     ( __param(3, IConfigurationService)),
-    ( __param(4, IHostService))
+    ( __param(4, IHostService)),
+    ( __param(5, IWorkbenchEnvironmentService))
 ], AuxiliaryWindow));
 let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends Disposable {
     static { BrowserAuxiliaryWindowService_1 = this; }
     static { this.DEFAULT_SIZE = { width: 800, height: 600 }; }
     static { this.WINDOW_IDS = getWindowId(mainWindow) + 1; }
-    constructor(layoutService, dialogService, configurationService, telemetryService, hostService) {
+    constructor(layoutService, dialogService, configurationService, telemetryService, hostService, environmentService) {
         super();
         this.layoutService = layoutService;
         this.dialogService = dialogService;
         this.configurationService = configurationService;
         this.telemetryService = telemetryService;
         this.hostService = hostService;
+        this.environmentService = environmentService;
         this._onDidOpenAuxiliaryWindow = this._register(( new Emitter()));
         this.onDidOpenAuxiliaryWindow = this._onDidOpenAuxiliaryWindow.event;
         this.windows = ( new Map());
@@ -142,7 +162,8 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
             container,
             stylesLoaded,
             this.configurationService,
-            this.hostService
+            this.hostService,
+            this.environmentService
         ));
     }
     async openWindow(options) {
@@ -171,7 +192,7 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         const auxiliaryWindow = mainWindow.open('about:blank', undefined, `popup=yes,left=${newWindowBounds.x},top=${newWindowBounds.y},width=${newWindowBounds.width},height=${newWindowBounds.height}`);
         if (!auxiliaryWindow && isWeb) {
             return (await this.dialogService.prompt({
-                type: Severity.Warning,
+                type: Severity$1.Warning,
                 message: ( localizeWithPath(
                     'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
                     'unableToOpenWindow',
@@ -201,14 +222,11 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         return BrowserAuxiliaryWindowService_1.WINDOW_IDS++;
     }
     createContainer(auxiliaryWindow, disposables, options) {
-        this.patchMethods(auxiliaryWindow);
         this.applyMeta(auxiliaryWindow);
         const { stylesLoaded } = this.applyCSS(auxiliaryWindow, disposables);
         const container = this.applyHTML(auxiliaryWindow, disposables);
         return { stylesLoaded, container };
     }
-    patchMethods(auxiliaryWindow) {
-    }
     applyMeta(auxiliaryWindow) {
         for (const metaTag of ['meta[charset="utf-8"]', 'meta[http-equiv="Content-Security-Policy"]', 'meta[name="viewport"]', 'meta[name="theme-color"]']) {
             const metaElement = mainWindow.document.querySelector(metaTag);
@@ -234,9 +252,11 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         const mapOriginalToClone = ( new Map());
         const stylesLoaded = ( new Barrier());
         stylesLoaded.wait().then(() => mark('code/auxiliaryWindow/didLoadCSSStyles'));
-        let pendingLinkSettles = 0;
-        function onLinkSettled(_event) {
-            if (!--pendingLinkSettles) {
+        const pendingLinksDisposables = disposables.add(( new DisposableStore()));
+        let pendingLinksToSettle = 0;
+        function onLinkSettled() {
+            if (--pendingLinksToSettle === 0) {
+                pendingLinksDisposables.dispose();
                 stylesLoaded.open();
             }
         }
@@ -245,18 +265,22 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
                 return;
             }
             const clonedNode = auxiliaryWindow.document.head.appendChild(originalNode.cloneNode(true));
-            if (originalNode.tagName === 'LINK') {
-                pendingLinkSettles++;
-                disposables.add(addDisposableListener(clonedNode, 'load', onLinkSettled));
-                disposables.add(addDisposableListener(clonedNode, 'error', onLinkSettled));
+            if (originalNode.tagName.toLowerCase() === 'link') {
+                pendingLinksToSettle++;
+                pendingLinksDisposables.add(addDisposableListener(clonedNode, 'load', onLinkSettled));
+                pendingLinksDisposables.add(addDisposableListener(clonedNode, 'error', onLinkSettled));
             }
             mapOriginalToClone.set(originalNode, clonedNode);
         }
-        pendingLinkSettles++;
-        for (const originalNode of mainWindow.document.head.querySelectorAll('link[rel="stylesheet"], style')) {
-            cloneNode(originalNode);
+        pendingLinksToSettle++;
+        try {
+            for (const originalNode of mainWindow.document.head.querySelectorAll('link[rel="stylesheet"], style')) {
+                cloneNode(originalNode);
+            }
+        }
+        finally {
+            onLinkSettled();
         }
-        onLinkSettled();
         disposables.add(cloneGlobalStylesheets(auxiliaryWindow));
         disposables.add(sharedMutationObserver.observe(mainWindow.document.head, disposables, { childList: true, subtree: true })(mutations => {
             for (const mutation of mutations) {
@@ -311,6 +335,7 @@ BrowserAuxiliaryWindowService = BrowserAuxiliaryWindowService_1 = ( __decorate([
     ( __param(1, IDialogService)),
     ( __param(2, IConfigurationService)),
     ( __param(3, ITelemetryService)),
-    ( __param(4, IHostService))
+    ( __param(4, IHostService)),
+    ( __param(5, IWorkbenchEnvironmentService))
 ], BrowserAuxiliaryWindowService));
 export { AuxiliaryWindow, BrowserAuxiliaryWindowService, IAuxiliaryWindowService };

package/vscode/src/vs/workbench/services/banner/browser/bannerService.d.ts

@@ -11,7 +11,7 @@ interface IBannerItem {
     readonly actions?: ILinkDescriptor[];
     readonly ariaLabel?: string;
     readonly onClose?: () => void;
-    readonly disableCloseAction?: boolean;
+    readonly closeLabel?: string;
 }
 declare const IBannerService: ServiceIdentifier<IBannerService>;
 interface IBannerService {

package/vscode/src/vs/workbench/services/editor/browser/codeEditorService.js

@@ -3,6 +3,7 @@ import { isCodeEditor, isDiffEditor, isCompositeEditor, getCodeEditor } from '..
 import { AbstractCodeEditorService } from '../../../../editor/browser/services/abstractCodeEditorService.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.js';
 import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from '../common/editorService.js';
+import '../../../../platform/instantiation/common/instantiation.js';
 import { isEqual } from '../../../../base/common/resources.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
 import { applyTextEditorOptions } from '../../../common/editor/editorOptions.js';

package/vscode/src/vs/workbench/services/editor/browser/editorPaneService.js

@@ -1,3 +1,4 @@
+import '../../../../platform/instantiation/common/instantiation.js';
 import { EditorPaneDescriptor } from '../../../browser/editor.js';
 class EditorPaneService {
     constructor() {

package/vscode/src/vs/workbench/services/editor/browser/editorResolverService.js

@@ -6,7 +6,7 @@ import { isEqual, extname, basename } from '../../../../base/common/resources.js
 import { URI } from '../../../../base/common/uri.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
 import { EditorResolution, EditorActivation } from '../../../../platform/editor/common/editor.js';
-import { isResourceSideBySideEditorInput, EditorResourceAccessor, SideBySideEditor, isEditorInputWithOptions, DEFAULT_EDITOR_ASSOCIATION, isResourceDiffEditorInput, isEditorInputWithOptionsAndGroup, isResourceMergeEditorInput, isResourceDiffListEditorInput, isUntitledResourceEditorInput } from '../../../common/editor.js';
+import { isResourceSideBySideEditorInput, EditorResourceAccessor, SideBySideEditor, isEditorInputWithOptions, DEFAULT_EDITOR_ASSOCIATION, isResourceDiffEditorInput, isEditorInputWithOptionsAndGroup, isResourceMergeEditorInput, isResourceMultiDiffEditorInput, isUntitledResourceEditorInput } from '../../../common/editor.js';
 import { IEditorGroupsService } from '../common/editorGroupsService.js';
 import { Schemas } from '../../../../base/common/network.js';
 import { globMatchesResource, editorsAssociationsSettingId, RegisteredEditorPriority, priorityToRank } from '../common/editorResolverService.js';
@@ -50,9 +50,9 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         this._register(this.storageService.onWillSaveState(() => {
             this.cacheEditors();
         }));
-        this.extensionService.onDidRegisterExtensions(() => {
+        this._register(this.extensionService.onDidRegisterExtensions(() => {
             this.cache = undefined;
-        });
+        }));
     }
     resolveUntypedInputAndGroup(editor, preferredGroup) {
         const untypedEditor = editor;
@@ -358,7 +358,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             const inputWithOptions = await selectedEditor.editorFactoryObject.createDiffEditorInput(editor, group);
             return { editor: inputWithOptions.editor, options: inputWithOptions.options ?? options };
         }
-        if (isResourceDiffListEditorInput(editor)) {
+        if (isResourceMultiDiffEditorInput(editor)) {
             if (!selectedEditor.editorFactoryObject.createMultiDiffEditorInput) {
                 return;
             }
@@ -380,9 +380,15 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         }
         const singleEditorPerResource = typeof selectedEditor.options?.singlePerResource === 'function' ? selectedEditor.options.singlePerResource() : selectedEditor.options?.singlePerResource;
         if (singleEditorPerResource) {
-            const foundInput = await this.moveExistingEditorForResource(resource, selectedEditor.editorInfo.id, group);
-            if (foundInput) {
-                return { editor: foundInput, options };
+            const existingEditors = this.findExistingEditorsForResource(resource, selectedEditor.editorInfo.id);
+            if (existingEditors.length) {
+                const editor = await this.moveExistingEditorForResource(existingEditors, group);
+                if (editor) {
+                    return { editor, options };
+                }
+                else {
+                    return;
+                }
             }
         }
         if (!selectedEditor.editorFactoryObject.createEditorInput) {
@@ -393,13 +399,9 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         const input = inputWithOptions.editor;
         return { editor: input, options };
     }
-    async moveExistingEditorForResource(resource, viewType, targetGroup) {
-        const editorInfoForResource = this.findExistingEditorsForResource(resource, viewType);
-        if (!editorInfoForResource.length) {
-            return;
-        }
-        const editorToUse = editorInfoForResource[0];
-        for (const { editor, group } of editorInfoForResource) {
+    async moveExistingEditorForResource(existingEditorsForResource, targetGroup) {
+        const editorToUse = existingEditorsForResource[0];
+        for (const { editor, group } of existingEditorsForResource) {
             if (editor !== editorToUse.editor) {
                 const closed = await group.closeEditor(editor);
                 if (!closed) {
@@ -408,10 +410,12 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             }
         }
         if (targetGroup.id !== editorToUse.group.id) {
-            editorToUse.group.moveEditor(editorToUse.editor, targetGroup);
-            return editorToUse.editor;
+            const moved = editorToUse.group.moveEditor(editorToUse.editor, targetGroup);
+            if (!moved) {
+                return;
+            }
         }
-        return;
+        return editorToUse.editor;
     }
     findExistingEditorsForResource(resource, editorId) {
         const out = [];

package/vscode/src/vs/workbench/services/editor/common/customEditorLabelService.d.ts

@@ -0,0 +1,12 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event } from '../../../../base/common/event.js';
+import { URI } from '../../../../base/common/uri.js';
+
+declare const ICustomEditorLabelService: ServiceIdentifier<ICustomEditorLabelService>;
+interface ICustomEditorLabelService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChange: Event<void>;
+    getName(resource: URI): string | undefined;
+}
+
+export { ICustomEditorLabelService };

package/vscode/src/vs/workbench/services/editor/common/customEditorLabelService.js

@@ -0,0 +1,144 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { parse } from '../../../../base/common/glob.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { isAbsolute, parse as parse$1 } from '../../../../base/common/path.js';
+import { relativePath } from '../../../../base/common/resources.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+var CustomEditorLabelService_1;
+let CustomEditorLabelService = class CustomEditorLabelService extends Disposable {
+    static { CustomEditorLabelService_1 = this; }
+    static { this.SETTING_ID_PATTERNS = 'workbench.editor.customLabels.patterns'; }
+    static { this.SETTING_ID_ENABLED = 'workbench.editor.customLabels.enabled'; }
+    constructor(configurationService, workspaceContextService) {
+        super();
+        this.configurationService = configurationService;
+        this.workspaceContextService = workspaceContextService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.patterns = [];
+        this.enabled = true;
+        this._templateRegexValidation = /[a-zA-Z0-9]/;
+        this._parsedTemplateExpression = /\$\{(dirname|filename|extname|dirname\((\d+)\))\}/g;
+        this.storeEnablementState();
+        this.storeCustomPatterns();
+        this.registerListernes();
+    }
+    registerListernes() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(CustomEditorLabelService_1.SETTING_ID_ENABLED)) {
+                const oldEnablement = this.enabled;
+                this.storeEnablementState();
+                if (oldEnablement !== this.enabled && this.patterns.length > 0) {
+                    this._onDidChange.fire();
+                }
+            }
+            else if (e.affectsConfiguration(CustomEditorLabelService_1.SETTING_ID_PATTERNS)) {
+                this.storeCustomPatterns();
+                this._onDidChange.fire();
+            }
+        }));
+    }
+    storeEnablementState() {
+        this.enabled = this.configurationService.getValue(CustomEditorLabelService_1.SETTING_ID_ENABLED);
+    }
+    storeCustomPatterns() {
+        this.patterns = [];
+        const customLabelPatterns = this.configurationService.getValue(CustomEditorLabelService_1.SETTING_ID_PATTERNS);
+        for (const pattern in customLabelPatterns) {
+            const template = customLabelPatterns[pattern];
+            if (!this._templateRegexValidation.test(template)) {
+                continue;
+            }
+            const isAbsolutePath = isAbsolute(pattern);
+            const parsedPattern = parse(pattern);
+            this.patterns.push({ pattern, template, isAbsolutePath, parsedPattern });
+        }
+        this.patterns.sort((a, b) => this.patternWeight(b.pattern) - this.patternWeight(a.pattern));
+    }
+    patternWeight(pattern) {
+        let weight = 0;
+        for (const fragment of pattern.split('/')) {
+            if (fragment === '**') {
+                weight += 1;
+            }
+            else if (fragment === '*') {
+                weight += 10;
+            }
+            else if (fragment.includes('*') || fragment.includes('?')) {
+                weight += 50;
+            }
+            else if (fragment !== '') {
+                weight += 100;
+            }
+        }
+        return weight;
+    }
+    getName(resource) {
+        if (!this.enabled) {
+            return undefined;
+        }
+        return this.applyPatterns(resource);
+    }
+    applyPatterns(resource) {
+        if (this.patterns.length === 0) {
+            return undefined;
+        }
+        const root = this.workspaceContextService.getWorkspaceFolder(resource);
+        let relativePath$1;
+        for (const pattern of this.patterns) {
+            let relevantPath;
+            if (root && !pattern.isAbsolutePath) {
+                relevantPath = relativePath$1 = relativePath$1 ?? relativePath(root.uri, resource) ?? resource.path;
+            }
+            else {
+                relevantPath = resource.path;
+            }
+            if (pattern.parsedPattern(relevantPath)) {
+                return this.applyTempate(pattern.template, resource);
+            }
+        }
+        return undefined;
+    }
+    applyTempate(template, resource) {
+        let parsedPath;
+        return template.replace(this._parsedTemplateExpression, (match, variable, arg) => {
+            parsedPath = parsedPath ?? parse$1(resource.path);
+            switch (variable) {
+                case 'filename':
+                    return parsedPath.name;
+                case 'extname':
+                    return parsedPath.ext.slice(1);
+                default: {
+                    const n = variable === 'dirname' ? 0 : parseInt(arg);
+                    const nthDir = this.getNthDirname(parsedPath, n);
+                    if (nthDir) {
+                        return nthDir;
+                    }
+                }
+            }
+            return match;
+        });
+    }
+    getNthDirname(path, n) {
+        const pathFragments = path.dir.split('/');
+        const length = pathFragments.length;
+        const nth = length - 1 - n;
+        if (nth < 0) {
+            return undefined;
+        }
+        const nthDir = pathFragments[nth];
+        if (nthDir === undefined || nthDir === '') {
+            return undefined;
+        }
+        return nthDir;
+    }
+};
+CustomEditorLabelService = CustomEditorLabelService_1 = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IWorkspaceContextService))
+], CustomEditorLabelService));
+const ICustomEditorLabelService = ( createDecorator('ICustomEditorLabelService'));
+export { CustomEditorLabelService, ICustomEditorLabelService };

package/vscode/src/vs/workbench/services/editor/common/editorGroupsService.d.ts

@@ -405,10 +405,6 @@ interface IEditorGroupsService extends IEditorGroupsContainer {
      * An event for when a new auxiliary editor part is created.
      */
     readonly onDidCreateAuxiliaryEditorPart: Event<IAuxiliaryEditorPartCreateEvent>;
-    /**
-     * Provides access to the currently active editor part.
-     */
-    readonly activePart: IEditorPart;
     /**
      * Provides access to the main window editor part.
      */
@@ -599,6 +595,10 @@ interface IEditorGroup {
      * Find out if the provided editor or index of editor is sticky in the group.
      */
     isSticky(editorOrIndex: EditorInput | number): boolean;
+    /**
+     * Find out if the provided editor or index of editor is transient in the group.
+     */
+    isTransient(editorOrIndex: EditorInput | number): boolean;
     /**
      * Find out if the provided editor is active in the group.
      */
@@ -612,12 +612,16 @@ interface IEditorGroup {
     contains(candidate: EditorInput | IUntypedEditorInput, options?: IMatchEditorOptions): boolean;
     /**
      * Move an editor from this group either within this group or to another group.
+     *
+     * @returns whether the editor was moved or not.
      */
-    moveEditor(editor: EditorInput, target: IEditorGroup, options?: IEditorOptions): void;
+    moveEditor(editor: EditorInput, target: IEditorGroup, options?: IEditorOptions): boolean;
     /**
      * Move editors from this group either within this group or to another group.
+     *
+     * @returns whether all editors were moved or not.
      */
-    moveEditors(editors: EditorInputWithOptions[], target: IEditorGroup): void;
+    moveEditors(editors: EditorInputWithOptions[], target: IEditorGroup): boolean;
     /**
      * Copy an editor from this group to another group.
      *

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.d.ts

@@ -51,13 +51,13 @@ type EditorInputFactoryResult = EditorInputWithOptions | Promise<EditorInputWith
 type EditorInputFactoryFunction = (editorInput: IResourceEditorInput | ITextResourceEditorInput, group: IEditorGroup) => EditorInputFactoryResult;
 type UntitledEditorInputFactoryFunction = (untitledEditorInput: IUntitledTextResourceEditorInput, group: IEditorGroup) => EditorInputFactoryResult;
 type DiffEditorInputFactoryFunction = (diffEditorInput: IResourceDiffEditorInput, group: IEditorGroup) => EditorInputFactoryResult;
-type DiffListEditorInputFactoryFunction = (diffEditorInput: IResourceMultiDiffEditorInput, group: IEditorGroup) => EditorInputFactoryResult;
+type MultiDiffEditorInputFactoryFunction = (multiDiffEditorInput: IResourceMultiDiffEditorInput, group: IEditorGroup) => EditorInputFactoryResult;
 type MergeEditorInputFactoryFunction = (mergeEditorInput: IResourceMergeEditorInput, group: IEditorGroup) => EditorInputFactoryResult;
 type EditorInputFactories = {
     createEditorInput?: EditorInputFactoryFunction;
     createUntitledEditorInput?: UntitledEditorInputFactoryFunction;
     createDiffEditorInput?: DiffEditorInputFactoryFunction;
-    createMultiDiffEditorInput?: DiffListEditorInputFactoryFunction;
+    createMultiDiffEditorInput?: MultiDiffEditorInputFactoryFunction;
     createMergeEditorInput?: MergeEditorInputFactoryFunction;
 };
 type EditorInputFactoryObject = AtLeastOne<EditorInputFactories>;
@@ -117,4 +117,4 @@ interface IEditorResolverService {
     getAllUserAssociations(): EditorAssociations;
 }
 
-export { type DiffEditorInputFactoryFunction, type DiffListEditorInputFactoryFunction, type EditorAssociation, type EditorAssociations, type EditorInputFactoryFunction, type EditorInputFactoryObject, IEditorResolverService, type MergeEditorInputFactoryFunction, type RegisteredEditorInfo, type RegisteredEditorOptions, RegisteredEditorPriority, type ResolvedEditor, ResolvedStatus, type UntitledEditorInputFactoryFunction };
+export { type DiffEditorInputFactoryFunction, type EditorAssociation, type EditorAssociations, type EditorInputFactoryFunction, type EditorInputFactoryObject, IEditorResolverService, type MergeEditorInputFactoryFunction, type MultiDiffEditorInputFactoryFunction, type RegisteredEditorInfo, type RegisteredEditorOptions, RegisteredEditorPriority, type ResolvedEditor, ResolvedStatus, type UntitledEditorInputFactoryFunction };

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagement.d.ts

@@ -1,7 +1,7 @@
 import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
 import { Event } from '../../../../base/common/event.js';
-import { IExtensionManifest, IExtension, ExtensionType } from '../../../../platform/extensions/common/extensions.js';
-import { InstallExtensionResult, InstallVSIXOptions, ILocalExtension, IGalleryExtension, InstallOptions, Metadata, IExtensionManagementService, InstallExtensionEvent, UninstallExtensionEvent, DidUninstallExtensionEvent } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { IExtension, IExtensionManifest, ExtensionType, IExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+import { InstallExtensionResult, ILocalExtension, InstallOptions, IGalleryExtension, Metadata, IExtensionManagementService, InstallExtensionEvent, UninstallExtensionEvent, DidUninstallExtensionEvent } from '../../../../platform/extensionManagement/common/extensionManagement.js';
 import { URI } from '../../../../base/common/uri.js';
 
 type DidChangeProfileEvent = {
@@ -17,6 +17,13 @@ interface IExtensionManagementServer {
     readonly label: string;
     readonly extensionManagementService: IProfileAwareExtensionManagementService;
 }
+interface IResourceExtension {
+    readonly identifier: IExtensionIdentifier;
+    readonly location: URI;
+    readonly manifest: IExtensionManifest;
+    readonly readmeUri?: URI;
+    readonly changelogUri?: URI;
+}
 type InstallExtensionOnServerEvent = InstallExtensionEvent & {
     server: IExtensionManagementServer;
 };
@@ -37,8 +44,13 @@ interface IWorkbenchExtensionManagementService extends IProfileAwareExtensionMan
     onUninstallExtension: Event<UninstallExtensionOnServerEvent>;
     onDidUninstallExtension: Event<DidUninstallExtensionOnServerEvent>;
     onDidChangeProfile: Event<DidChangeProfileForServerEvent>;
-    installVSIX(location: URI, manifest: IExtensionManifest, installOptions?: InstallVSIXOptions): Promise<ILocalExtension>;
+    onDidEnableExtensions: Event<IExtension[]>;
+    isWorkspaceExtensionsSupported(): boolean;
+    getExtensions(locations: URI[]): Promise<IResourceExtension[]>;
+    getInstalledWorkspaceExtensions(includeInvalid: boolean): Promise<ILocalExtension[]>;
+    installVSIX(location: URI, manifest: IExtensionManifest, installOptions?: InstallOptions): Promise<ILocalExtension>;
     installFromLocation(location: URI): Promise<ILocalExtension>;
+    installResourceExtension(extension: IResourceExtension, installOptions: InstallOptions): Promise<ILocalExtension>;
     updateFromGallery(gallery: IGalleryExtension, extension: ILocalExtension, installOptions?: InstallOptions): Promise<ILocalExtension>;
 }
 declare const enum EnablementState {
@@ -135,4 +147,4 @@ interface IWebExtensionsScannerService {
     scanExtensionManifest(extensionLocation: URI): Promise<IExtensionManifest | null>;
 }
 
-export { type DidChangeProfileEvent, type DidChangeProfileForServerEvent, type DidUninstallExtensionOnServerEvent, EnablementState, type IExtensionManagementServer, IProfileAwareExtensionManagementService, type IScannedExtension, IWebExtensionsScannerService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, type InstallExtensionOnServerEvent, type ScanOptions, type UninstallExtensionOnServerEvent };
+export { type DidChangeProfileEvent, type DidChangeProfileForServerEvent, type DidUninstallExtensionOnServerEvent, EnablementState, type IExtensionManagementServer, IProfileAwareExtensionManagementService, type IResourceExtension, type IScannedExtension, IWebExtensionsScannerService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, type InstallExtensionOnServerEvent, type ScanOptions, type UninstallExtensionOnServerEvent };

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagement.js

@@ -1,10 +1,21 @@
 import { createDecorator, refineServiceDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
 import { FileAccess } from '../../../../base/common/network.js';
+import { localizeWithPath } from '../../../../nls.js';
 const IProfileAwareExtensionManagementService = refineServiceDecorator(IExtensionManagementService);
 const IExtensionManagementServerService = ( createDecorator('extensionManagementServerService'));
 const getDefaultIconPath = () => ( ( FileAccess.asBrowserUri('vs/workbench/services/extensionManagement/common/media/defaultIcon.png')).toString(true));
 const IWorkbenchExtensionManagementService = refineServiceDecorator(IProfileAwareExtensionManagementService);
+const extensionsConfigurationNodeBase = {
+    id: 'extensions',
+    order: 30,
+    title: ( localizeWithPath(
+        'vs/workbench/services/extensionManagement/common/extensionManagement',
+        'extensionsConfigurationTitle',
+        "Extensions"
+    )),
+    type: 'object'
+};
 const IWorkbenchExtensionEnablementService = ( createDecorator('extensionEnablementService'));
 const IWebExtensionsScannerService = ( createDecorator('IWebExtensionsScannerService'));
-export { IExtensionManagementServerService, IProfileAwareExtensionManagementService, IWebExtensionsScannerService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, getDefaultIconPath };
+export { IExtensionManagementServerService, IProfileAwareExtensionManagementService, IWebExtensionsScannerService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, extensionsConfigurationNodeBase, getDefaultIconPath };