@codingame/monaco-vscode-api 5.3.0 → 6.0.1

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomains.js

@@ -0,0 +1,119 @@
+import { URI } from '../../../../base/common/uri.js';
+import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { IBrowserWorkbenchEnvironmentService } from '../../../services/environment/browser/environmentService.service.js';
+const _moduleId = "vs/workbench/contrib/url/browser/trustedDomains";
+const TRUSTED_DOMAINS_URI = ( (URI.parse('trustedDomains:/Trusted Domains')));
+const TRUSTED_DOMAINS_STORAGE_KEY = 'http.linkProtectionTrustedDomains';
+const TRUSTED_DOMAINS_CONTENT_STORAGE_KEY = 'http.linkProtectionTrustedDomainsContent';
+const manageTrustedDomainSettingsCommand = {
+    id: 'workbench.action.manageTrustedDomain',
+    description: {
+        description: ( localize2WithPath(_moduleId, 0, 'Manage Trusted Domains')),
+        args: []
+    },
+    handler: async (accessor) => {
+        const editorService = accessor.get(IEditorService);
+        editorService.openEditor({ resource: TRUSTED_DOMAINS_URI, languageId: 'jsonc', options: { pinned: true } });
+        return;
+    }
+};
+async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConfigure, resource, quickInputService, storageService, editorService, telemetryService) {
+    const parsedDomainToConfigure = ( (URI.parse(domainToConfigure)));
+    const toplevelDomainSegements = parsedDomainToConfigure.authority.split('.');
+    const domainEnd = toplevelDomainSegements.slice(toplevelDomainSegements.length - 2).join('.');
+    const topLevelDomain = '*.' + domainEnd;
+    const options = [];
+    options.push({
+        type: 'item',
+        label: ( localizeWithPath(_moduleId, 1, 'Trust {0}', domainToConfigure)),
+        id: 'trust',
+        toTrust: domainToConfigure,
+        picked: true
+    });
+    const isIP = toplevelDomainSegements.length === 4 &&
+        toplevelDomainSegements.every(segment => Number.isInteger(+segment) || Number.isInteger(+segment.split(':')[0]));
+    if (isIP) {
+        if (parsedDomainToConfigure.authority.includes(':')) {
+            const base = parsedDomainToConfigure.authority.split(':')[0];
+            options.push({
+                type: 'item',
+                label: ( localizeWithPath(_moduleId, 2, 'Trust {0} on all ports', base)),
+                toTrust: base + ':*',
+                id: 'trust'
+            });
+        }
+    }
+    else {
+        options.push({
+            type: 'item',
+            label: ( localizeWithPath(_moduleId, 3, 'Trust {0} and all its subdomains', domainEnd)),
+            toTrust: topLevelDomain,
+            id: 'trust'
+        });
+    }
+    options.push({
+        type: 'item',
+        label: ( localizeWithPath(_moduleId, 4, 'Trust all domains (disables link protection)')),
+        toTrust: '*',
+        id: 'trust'
+    });
+    options.push({
+        type: 'item',
+        label: ( localizeWithPath(_moduleId, 5, 'Manage Trusted Domains')),
+        id: 'manage'
+    });
+    const pickedResult = await quickInputService.pick(options, { activeItem: options[0] });
+    if (pickedResult && pickedResult.id) {
+        switch (pickedResult.id) {
+            case 'manage':
+                await editorService.openEditor({
+                    resource: TRUSTED_DOMAINS_URI.with({ fragment: ( (resource.toString())) }),
+                    languageId: 'jsonc',
+                    options: { pinned: true }
+                });
+                return trustedDomains;
+            case 'trust': {
+                const itemToTrust = pickedResult.toTrust;
+                if (trustedDomains.indexOf(itemToTrust) === -1) {
+                    storageService.remove(TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, StorageScope.APPLICATION);
+                    storageService.store(TRUSTED_DOMAINS_STORAGE_KEY, JSON.stringify([...trustedDomains, itemToTrust]), StorageScope.APPLICATION, StorageTarget.USER);
+                    return [...trustedDomains, itemToTrust];
+                }
+            }
+        }
+    }
+    return [];
+}
+async function readTrustedDomains(accessor) {
+    const { defaultTrustedDomains, trustedDomains } = readStaticTrustedDomains(accessor);
+    return {
+        defaultTrustedDomains,
+        trustedDomains,
+    };
+}
+function readStaticTrustedDomains(accessor) {
+    const storageService = accessor.get(IStorageService);
+    const productService = accessor.get(IProductService);
+    const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
+    const defaultTrustedDomains = [
+        ...(productService.linkProtectionTrustedDomains ?? []),
+        ...(environmentService.options?.additionalTrustedDomains ?? [])
+    ];
+    let trustedDomains = [];
+    try {
+        const trustedDomainsSrc = storageService.get(TRUSTED_DOMAINS_STORAGE_KEY, StorageScope.APPLICATION);
+        if (trustedDomainsSrc) {
+            trustedDomains = JSON.parse(trustedDomainsSrc);
+        }
+    }
+    catch (err) { }
+    return {
+        defaultTrustedDomains,
+        trustedDomains,
+    };
+}
+export { TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, TRUSTED_DOMAINS_STORAGE_KEY, configureOpenerTrustedDomainsHandler, manageTrustedDomainSettingsCommand, readStaticTrustedDomains, readTrustedDomains };

package/vscode/src/vs/workbench/contrib/webview/browser/webview.js

@@ -3,11 +3,18 @@ import { equals } from '../../../../base/common/arrays.js';
 import { isEqual } from '../../../../base/common/resources.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
 import { Memento } from '../../../common/memento.js';
 const KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE = ( new RawContextKey('webviewFindWidgetVisible', false));
 const KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED = ( new RawContextKey('webviewFindWidgetFocused', false));
 const KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED = ( new RawContextKey('webviewFindWidgetEnabled', false));
+var WebviewContentPurpose;
+( (function(WebviewContentPurpose) {
+    WebviewContentPurpose["NotebookRenderer"] = "notebookRenderer";
+    WebviewContentPurpose["CustomEditor"] = "customEditor";
+    WebviewContentPurpose["WebviewView"] = "webviewView";
+})(WebviewContentPurpose || (WebviewContentPurpose = {})));
 function areWebviewContentOptionsEqual(a, b) {
     return (a.allowMultipleAPIAcquire === b.allowMultipleAPIAcquire
         && a.allowScripts === b.allowScripts
@@ -28,7 +35,7 @@ function areEnableCommandUrisEqual(a, b) {
 let WebviewOriginStore = class WebviewOriginStore {
     constructor(rootStorageKey, storageService) {
         this._memento = ( new Memento(rootStorageKey, storageService));
-        this._state = this._memento.getMemento(-1 , 1 );
+        this._state = this._memento.getMemento(StorageScope.APPLICATION, StorageTarget.MACHINE);
     }
     getOrigin(viewType, additionalKey) {
         const key = this._getKey(viewType, additionalKey);
@@ -59,4 +66,4 @@ let ExtensionKeyedWebviewOriginStore = class ExtensionKeyedWebviewOriginStore {
 ExtensionKeyedWebviewOriginStore = ( __decorate([
     ( __param(1, IStorageService))
 ], ExtensionKeyedWebviewOriginStore));
-export { ExtensionKeyedWebviewOriginStore, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE, WebviewOriginStore, areWebviewContentOptionsEqual };
+export { ExtensionKeyedWebviewOriginStore, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE, WebviewContentPurpose, WebviewOriginStore, areWebviewContentOptionsEqual };

package/vscode/src/vs/workbench/contrib/webview/common/webview.js

@@ -1,3 +1,4 @@
+import { CharCode } from '../../../../base/common/charCode.js';
 import { Schemas } from '../../../../base/common/network.js';
 import { URI } from '../../../../base/common/uri.js';
 const webviewResourceBaseHost = 'vscode-cdn.net';
@@ -25,9 +26,9 @@ function asWebviewUri(resource, remoteInfo) {
 function encodeAuthority(authority) {
     return authority.replace(/./g, char => {
         const code = char.charCodeAt(0);
-        if (((code >= 97  && code <= 122) )
-            || ((code >= 65  && code <= 90) )
-            || ((code >= 48  && code <= 57) )) {
+        if ((code >= CharCode.a && code <= CharCode.z)
+            || (code >= CharCode.A && code <= CharCode.Z)
+            || (code >= CharCode.Digit0 && code <= CharCode.Digit9)) {
             return char;
         }
         return '-' + ( code.toString(16)).padStart(4, '0');

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditor.js

@@ -16,6 +16,7 @@ import { WebviewInput } from './webviewEditorInput.js';
 import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.service.js';
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
 import { IHostService } from '../../../services/host/browser/host.service.js';
+import { Parts } from '../../../services/layout/browser/layoutService.js';
 import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
 var WebviewEditor_1;
 const _moduleId = "vs/workbench/contrib/webviewPanel/browser/webviewEditor";
@@ -76,7 +77,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         super.focus();
         if (!this._onFocusWindowHandler.value && !isWeb) {
             this._onFocusWindowHandler.value = this._hostService.onDidChangeFocus(focused => {
-                if (focused && this._editorService.activeEditorPane === this && this._workbenchLayoutService.hasFocus("workbench.parts.editor" )) {
+                if (focused && this._editorService.activeEditorPane === this && this._workbenchLayoutService.hasFocus(Parts.EDITOR_PART)) {
                     this.focus();
                 }
             });
@@ -143,7 +144,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         if (!this._element?.isConnected) {
             return;
         }
-        const rootContainer = this._workbenchLayoutService.getContainer(this.window, "workbench.parts.editor" );
+        const rootContainer = this._workbenchLayoutService.getContainer(this.window, Parts.EDITOR_PART);
         webview.layoutWebviewOverElement(this._element.parentElement, dimension, rootContainer);
     }
     trackFocus(webview) {

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput.js

@@ -1,6 +1,7 @@
 import { Schemas } from '../../../../base/common/network.js';
 import { URI } from '../../../../base/common/uri.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
+import { EditorInputCapabilities } from '../../../common/editor.js';
 import { EditorInput } from '../../../common/editor/editorInput.js';
 class WebviewInput extends EditorInput {
     static { this.typeId = 'workbench.editors.webviewInput'; }
@@ -11,7 +12,7 @@ class WebviewInput extends EditorInput {
         return this.viewType;
     }
     get capabilities() {
-        return 2  | 8  | 128 ;
+        return EditorInputCapabilities.Readonly | EditorInputCapabilities.Singleton | EditorInputCapabilities.CanDropIntoEditor;
     }
     get resource() {
         return ( URI.from({

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewIconManager.js

@@ -2,6 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { createStyleSheet, asCSSUrl } from '../../../../base/browser/dom.js';
 import { DisposableStore } from '../../../../base/common/lifecycle.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { LifecyclePhase } from '../../../services/lifecycle/common/lifecycle.js';
 import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.service.js';
 let WebviewIconManager = class WebviewIconManager {
     constructor(_lifecycleService, _configService) {
@@ -37,7 +38,7 @@ let WebviewIconManager = class WebviewIconManager {
         this.updateStyleSheet();
     }
     async updateStyleSheet() {
-        await this._lifecycleService.when(1 );
+        await this._lifecycleService.when(LifecyclePhase.Starting);
         const cssRules = [];
         if (this._configService.getValue('workbench.iconTheme') !== null) {
             for (const [key, value] of this._icons) {

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.js

@@ -6,13 +6,13 @@ import { isCancellationError } from '../../../../base/common/errors.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Iterable } from '../../../../base/common/iterator.js';
 import { Disposable, toDisposable, combinedDisposable } from '../../../../base/common/lifecycle.js';
-import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
 import { EditorActivation } from '../../../../platform/editor/common/editor.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
 import { IWebviewService } from '../../webview/browser/webview.service.js';
 import { CONTEXT_ACTIVE_WEBVIEW_PANEL_ID } from './webviewEditor.js';
 import { WebviewIconManager } from './webviewIconManager.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.service.js';
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
 import { WebviewInput } from './webviewEditorInput.js';
 import { IWebviewWorkbenchService } from './webviewWorkbenchService.service.js';
@@ -89,7 +89,7 @@ class RevivalPool {
     }
 }
 let WebviewEditorService = class WebviewEditorService extends Disposable {
-    constructor(contextKeyService, _editorService, _instantiationService, _webviewService) {
+    constructor(editorGroupsService, _editorService, _instantiationService, _webviewService) {
         super();
         this._editorService = _editorService;
         this._instantiationService = _instantiationService;
@@ -98,8 +98,11 @@ let WebviewEditorService = class WebviewEditorService extends Disposable {
         this._revivalPool = ( new RevivalPool());
         this._onDidChangeActiveWebviewEditor = this._register(( new Emitter()));
         this.onDidChangeActiveWebviewEditor = this._onDidChangeActiveWebviewEditor.event;
-        this._activeWebviewPanelIdContext = CONTEXT_ACTIVE_WEBVIEW_PANEL_ID.bindTo(contextKeyService);
         this._iconManager = this._register(this._instantiationService.createInstance(WebviewIconManager));
+        this._register(editorGroupsService.registerContextKeyProvider({
+            contextKey: CONTEXT_ACTIVE_WEBVIEW_PANEL_ID,
+            getGroupContextKeyValue: (group) => this.getWebviewId(group.activeEditor),
+        }));
         this._register(_editorService.onDidActiveEditorChange(() => {
             this.updateActiveWebview();
         }));
@@ -111,6 +114,21 @@ let WebviewEditorService = class WebviewEditorService extends Disposable {
     get iconManager() {
         return this._iconManager;
     }
+    getWebviewId(input) {
+        let webviewInput;
+        if (input instanceof WebviewInput) {
+            webviewInput = input;
+        }
+        else if (input instanceof DiffEditorInput) {
+            if (input.primary instanceof WebviewInput) {
+                webviewInput = input.primary;
+            }
+            else if (input.secondary instanceof WebviewInput) {
+                webviewInput = input.secondary;
+            }
+        }
+        return webviewInput?.webview.providedViewType ?? '';
+    }
     updateActiveWebview() {
         const activeInput = this._editorService.activeEditor;
         let newActiveWebview;
@@ -125,12 +143,6 @@ let WebviewEditorService = class WebviewEditorService extends Disposable {
                 newActiveWebview = activeInput.secondary;
             }
         }
-        if (newActiveWebview) {
-            this._activeWebviewPanelIdContext.set(newActiveWebview.webview.providedViewType ?? '');
-        }
-        else {
-            this._activeWebviewPanelIdContext.reset();
-        }
         if (newActiveWebview !== this._activeWebview) {
             this._activeWebview = newActiveWebview;
             this._onDidChangeActiveWebviewEditor.fire(newActiveWebview);
@@ -211,7 +223,7 @@ let WebviewEditorService = class WebviewEditorService extends Disposable {
     }
 };
 WebviewEditorService = ( __decorate([
-    ( __param(0, IContextKeyService)),
+    ( __param(0, IEditorGroupsService)),
     ( __param(1, IEditorService)),
     ( __param(2, IInstantiationService)),
     ( __param(3, IWebviewService))

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

@@ -1,11 +1,14 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { Disposable, DisposableMap, isDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Disposable, DisposableMap, isDisposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
 import { isFalsyOrWhitespace } from '../../../../base/common/strings.js';
 import { isString } from '../../../../base/common/types.js';
 import { localizeWithPath } from '../../../../nls.js';
+import '../../../../platform/instantiation/common/extensions.js';
 import { IAuthenticationAccessService } from './authenticationAccessService.service.js';
 import '../../../../platform/instantiation/common/instantiation.js';
+import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.service.js';
+import { ActivationKind } from '../../extensions/common/extensions.js';
 import { IExtensionService } from '../../extensions/common/extensions.service.js';
 const _moduleId = "vs/workbench/services/authentication/browser/authenticationService";
 function getAuthenticationProviderActivationEvent(id) { return `onAuthenticationRequest:${id}`; }
@@ -28,9 +31,10 @@ async function getCurrentAuthenticationSessionInfo(secretStorageService, product
     return undefined;
 }
 let AuthenticationService = class AuthenticationService extends Disposable {
-    constructor(_extensionService, authenticationAccessService) {
+    constructor(_extensionService, authenticationAccessService, _environmentService) {
         super();
         this._extensionService = _extensionService;
+        this._environmentService = _environmentService;
         this._onDidRegisterAuthenticationProvider = this._register(( new Emitter()));
         this.onDidRegisterAuthenticationProvider = this._onDidRegisterAuthenticationProvider.event;
         this._onDidUnregisterAuthenticationProvider = this._register(( new Emitter()));
@@ -53,10 +57,19 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                 }
             });
         }));
+        this._registerEnvContributedAuthenticationProviders();
     }
     get declaredProviders() {
         return this._declaredProviders;
     }
+    _registerEnvContributedAuthenticationProviders() {
+        if (!this._environmentService.options?.authenticationProviders?.length) {
+            return;
+        }
+        for (const provider of this._environmentService.options.authenticationProviders) {
+            this.registerAuthenticationProvider(provider.id, provider);
+        }
+    }
     registerDeclaredAuthenticationProvider(provider) {
         if (isFalsyOrWhitespace(provider.id)) {
             throw ( new Error(
@@ -154,13 +167,14 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         }
     }
     async tryActivateProvider(providerId, activateImmediate) {
-        await this._extensionService.activateByEvent(getAuthenticationProviderActivationEvent(providerId), activateImmediate ? 1  : 0 );
+        await this._extensionService.activateByEvent(getAuthenticationProviderActivationEvent(providerId), activateImmediate ? ActivationKind.Immediate : ActivationKind.Normal);
         let provider = this._authenticationProviders.get(providerId);
         if (provider) {
             return provider;
         }
+        const store = ( new DisposableStore());
         const didRegister = ( new Promise((resolve, _) => {
-            this.onDidRegisterAuthenticationProvider(e => {
+            store.add(Event.once(this.onDidRegisterAuthenticationProvider)(e => {
                 if (e.id === providerId) {
                     provider = this._authenticationProviders.get(providerId);
                     if (provider) {
@@ -170,18 +184,20 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                         throw ( new Error(`No authentication provider '${providerId}' is currently registered.`));
                     }
                 }
-            });
+            }));
         }));
         const didTimeout = ( new Promise((_, reject) => {
-            setTimeout(() => {
+            const handle = setTimeout(() => {
                 reject('Timed out waiting for authentication provider to register');
             }, 5000);
+            store.add(toDisposable(() => clearTimeout(handle)));
         }));
-        return Promise.race([didRegister, didTimeout]);
+        return Promise.race([didRegister, didTimeout]).finally(() => store.dispose());
     }
 };
 AuthenticationService = ( __decorate([
     ( __param(0, IExtensionService)),
-    ( __param(1, IAuthenticationAccessService))
+    ( __param(1, IAuthenticationAccessService)),
+    ( __param(2, IBrowserWorkbenchEnvironmentService))
 ], AuthenticationService));
 export { AuthenticationService, getAuthenticationProviderActivationEvent, getCurrentAuthenticationSessionInfo };