@codingame/monaco-vscode-quickaccess-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,137 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { parse } from 'vscode/vscode/vs/base/common/json';
+import { FileType, IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, readTrustedDomains, TRUSTED_DOMAINS_STORAGE_KEY } from './trustedDomains.js';
+import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+const TRUSTED_DOMAINS_SCHEMA = 'trustedDomains';
+const TRUSTED_DOMAINS_STAT = {
+    type: FileType.File,
+    ctime: Date.now(),
+    mtime: Date.now(),
+    size: 0
+};
+const CONFIG_HELP_TEXT_PRE = `// Links matching one or more entries in the list below can be opened without link protection.
+// The following examples show what entries can look like:
+// - "https://microsoft.com": Matches this specific domain using https
+// - "https://microsoft.com:8080": Matches this specific domain on this port using https
+// - "https://microsoft.com:*": Matches this specific domain on any port using https
+// - "https://microsoft.com/foo": Matches https://microsoft.com/foo and https://microsoft.com/foo/bar,
+//   but not https://microsoft.com/foobar or https://microsoft.com/bar
+// - "https://*.microsoft.com": Match all domains ending in "microsoft.com" using https
+// - "microsoft.com": Match this specific domain using either http or https
+// - "*.microsoft.com": Match all domains ending in "microsoft.com" using either http or https
+// - "http://192.168.0.1: Matches this specific IP using http
+// - "http://192.168.0.*: Matches all IP's with this prefix using http
+// - "*": Match all domains using either http or https
+//
+`;
+const CONFIG_HELP_TEXT_AFTER = `//
+// You can use the "Manage Trusted Domains" command to open this file.
+// Save this file to apply the trusted domains rules.
+`;
+const CONFIG_PLACEHOLDER_TEXT = `[
+	// "https://microsoft.com"
+]`;
+function computeTrustedDomainContent(defaultTrustedDomains, trustedDomains, userTrustedDomains, workspaceTrustedDomains, configuring) {
+    let content = CONFIG_HELP_TEXT_PRE;
+    if (defaultTrustedDomains.length > 0) {
+        content += `// By default, VS Code trusts "localhost" as well as the following domains:\n`;
+        defaultTrustedDomains.forEach(d => {
+            content += `// - "${d}"\n`;
+        });
+    }
+    else {
+        content += `// By default, VS Code trusts "localhost".\n`;
+    }
+    if (userTrustedDomains.length) {
+        content += `//\n// Additionally, the following domains are trusted based on your logged-in Accounts:\n`;
+        userTrustedDomains.forEach(d => {
+            content += `// - "${d}"\n`;
+        });
+    }
+    if (workspaceTrustedDomains.length) {
+        content += `//\n// Further, the following domains are trusted based on your workspace configuration:\n`;
+        workspaceTrustedDomains.forEach(d => {
+            content += `// - "${d}"\n`;
+        });
+    }
+    content += CONFIG_HELP_TEXT_AFTER;
+    content += configuring ? `\n// Currently configuring trust for ${configuring}\n` : '';
+    if (trustedDomains.length === 0) {
+        content += CONFIG_PLACEHOLDER_TEXT;
+    }
+    else {
+        content += JSON.stringify(trustedDomains, null, 2);
+    }
+    return content;
+}
+let TrustedDomainsFileSystemProvider = class TrustedDomainsFileSystemProvider {
+    static { this.ID = 'workbench.contrib.trustedDomainsFileSystemProvider'; }
+    constructor(fileService, storageService, instantiationService) {
+        this.fileService = fileService;
+        this.storageService = storageService;
+        this.instantiationService = instantiationService;
+        this.capabilities = 2 ;
+        this.onDidChangeCapabilities = Event.None;
+        this.onDidChangeFile = Event.None;
+        this.fileService.registerProvider(TRUSTED_DOMAINS_SCHEMA, this);
+    }
+    stat(resource) {
+        return Promise.resolve(TRUSTED_DOMAINS_STAT);
+    }
+    async readFile(resource) {
+        let trustedDomainsContent = this.storageService.get(TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, -1 );
+        const configuring = resource.fragment;
+        const { defaultTrustedDomains, trustedDomains, userDomains, workspaceDomains } = await this.instantiationService.invokeFunction(readTrustedDomains);
+        if (!trustedDomainsContent ||
+            trustedDomainsContent.indexOf(CONFIG_HELP_TEXT_PRE) === -1 ||
+            trustedDomainsContent.indexOf(CONFIG_HELP_TEXT_AFTER) === -1 ||
+            trustedDomainsContent.indexOf(configuring ?? '') === -1 ||
+            ( [...defaultTrustedDomains, ...trustedDomains, ...userDomains, ...workspaceDomains].some(d => !assertIsDefined(trustedDomainsContent).includes(d)))) {
+            trustedDomainsContent = computeTrustedDomainContent(defaultTrustedDomains, trustedDomains, userDomains, workspaceDomains, configuring);
+        }
+        const buffer = VSBuffer.fromString(trustedDomainsContent).buffer;
+        return buffer;
+    }
+    writeFile(resource, content, opts) {
+        try {
+            const trustedDomainsContent = ( VSBuffer.wrap(content).toString());
+            const trustedDomains = parse(trustedDomainsContent);
+            this.storageService.store(TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, trustedDomainsContent, -1 , 0 );
+            this.storageService.store(TRUSTED_DOMAINS_STORAGE_KEY, JSON.stringify(trustedDomains) || '', -1 , 0 );
+        }
+        catch (err) { }
+        return Promise.resolve();
+    }
+    watch(resource, opts) {
+        return {
+            dispose() {
+                return;
+            }
+        };
+    }
+    mkdir(resource) {
+        return Promise.resolve(undefined);
+    }
+    readdir(resource) {
+        return Promise.resolve(undefined);
+    }
+    delete(resource, opts) {
+        return Promise.resolve(undefined);
+    }
+    rename(from, to, opts) {
+        return Promise.resolve(undefined);
+    }
+};
+TrustedDomainsFileSystemProvider = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IInstantiationService))
+], TrustedDomainsFileSystemProvider));
+
+export { TrustedDomainsFileSystemProvider };

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

@@ -0,0 +1,205 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { WindowIdleValue } from 'vscode/vscode/vs/base/browser/dom';
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { matchesScheme, Schemas } from 'vscode/vscode/vs/base/common/network';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceTrustManagementService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
+import { readAuthenticationTrustedDomains, readWorkspaceTrustedDomains, readStaticTrustedDomains, configureOpenerTrustedDomainsHandler } from './trustedDomains.js';
+import { testUrlMatchesGlob } from 'vscode/vscode/vs/workbench/contrib/url/common/urlGlob';
+import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+let OpenerValidatorContributions = class OpenerValidatorContributions {
+    constructor(_openerService, _storageService, _dialogService, _productService, _quickInputService, _editorService, _clipboardService, _telemetryService, _instantiationService, _authenticationService, _workspaceContextService, _configurationService, _workspaceTrustService) {
+        this._openerService = _openerService;
+        this._storageService = _storageService;
+        this._dialogService = _dialogService;
+        this._productService = _productService;
+        this._quickInputService = _quickInputService;
+        this._editorService = _editorService;
+        this._clipboardService = _clipboardService;
+        this._telemetryService = _telemetryService;
+        this._instantiationService = _instantiationService;
+        this._authenticationService = _authenticationService;
+        this._workspaceContextService = _workspaceContextService;
+        this._configurationService = _configurationService;
+        this._workspaceTrustService = _workspaceTrustService;
+        this._openerService.registerValidator({ shouldOpen: (uri, options) => this.validateLink(uri, options) });
+        this._readAuthenticationTrustedDomainsResult = ( new WindowIdleValue(
+            mainWindow,
+            () => this._instantiationService.invokeFunction(readAuthenticationTrustedDomains)
+        ));
+        this._authenticationService.onDidRegisterAuthenticationProvider(() => {
+            this._readAuthenticationTrustedDomainsResult?.dispose();
+            this._readAuthenticationTrustedDomainsResult = ( new WindowIdleValue(
+                mainWindow,
+                () => this._instantiationService.invokeFunction(readAuthenticationTrustedDomains)
+            ));
+        });
+        this._readWorkspaceTrustedDomainsResult = ( new WindowIdleValue(
+            mainWindow,
+            () => this._instantiationService.invokeFunction(readWorkspaceTrustedDomains)
+        ));
+        this._workspaceContextService.onDidChangeWorkspaceFolders(() => {
+            this._readWorkspaceTrustedDomainsResult?.dispose();
+            this._readWorkspaceTrustedDomainsResult = ( new WindowIdleValue(
+                mainWindow,
+                () => this._instantiationService.invokeFunction(readWorkspaceTrustedDomains)
+            ));
+        });
+    }
+    async validateLink(resource, openOptions) {
+        if (!matchesScheme(resource, Schemas.http) && !matchesScheme(resource, Schemas.https)) {
+            return true;
+        }
+        if (openOptions?.fromWorkspace && this._workspaceTrustService.isWorkspaceTrusted() && !this._configurationService.getValue('workbench.trustedDomains.promptInTrustedWorkspace')) {
+            return true;
+        }
+        const originalResource = resource;
+        let resourceUri;
+        if (typeof resource === 'string') {
+            resourceUri = ( URI.parse(resource));
+        }
+        else {
+            resourceUri = resource;
+        }
+        const { scheme, authority, path, query, fragment } = resourceUri;
+        const domainToOpen = `${scheme}://${authority}`;
+        const [workspaceDomains, userDomains] = await Promise.all([this._readWorkspaceTrustedDomainsResult.value, this._readAuthenticationTrustedDomainsResult.value]);
+        const { defaultTrustedDomains, trustedDomains, } = this._instantiationService.invokeFunction(readStaticTrustedDomains);
+        const allTrustedDomains = [...defaultTrustedDomains, ...trustedDomains, ...userDomains, ...workspaceDomains];
+        if (isURLDomainTrusted(resourceUri, allTrustedDomains)) {
+            return true;
+        }
+        else {
+            let formattedLink = `${scheme}://${authority}${path}`;
+            const linkTail = `${query ? '?' + query : ''}${fragment ? '#' + fragment : ''}`;
+            const remainingLength = Math.max(0, 60 - formattedLink.length);
+            const linkTailLengthToKeep = Math.min(Math.max(5, remainingLength), linkTail.length);
+            if (linkTailLengthToKeep === linkTail.length) {
+                formattedLink += linkTail;
+            }
+            else {
+                formattedLink += linkTail.charAt(0) + '...' + linkTail.substring(linkTail.length - linkTailLengthToKeep + 1);
+            }
+            const { result } = await this._dialogService.prompt({
+                type: Severity$1.Info,
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/url/browser/trustedDomainsValidator',
+                    'openExternalLinkAt',
+                    'Do you want {0} to open the external website?',
+                    this._productService.nameShort
+                )),
+                detail: typeof originalResource === 'string' ? originalResource : formattedLink,
+                buttons: [
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/url/browser/trustedDomainsValidator',
+                            { key: 'open', comment: ['&& denotes a mnemonic'] },
+                            '&&Open'
+                        )),
+                        run: () => true
+                    },
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/url/browser/trustedDomainsValidator',
+                            { key: 'copy', comment: ['&& denotes a mnemonic'] },
+                            '&&Copy'
+                        )),
+                        run: () => {
+                            this._clipboardService.writeText(typeof originalResource === 'string' ? originalResource : ( resourceUri.toString(true)));
+                            return false;
+                        }
+                    },
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/url/browser/trustedDomainsValidator',
+                            { key: 'configureTrustedDomains', comment: ['&& denotes a mnemonic'] },
+                            'Configure &&Trusted Domains'
+                        )),
+                        run: async () => {
+                            const pickedDomains = await configureOpenerTrustedDomainsHandler(trustedDomains, domainToOpen, resourceUri, this._quickInputService, this._storageService, this._editorService);
+                            if (pickedDomains.indexOf('*') !== -1) {
+                                return true;
+                            }
+                            if (isURLDomainTrusted(resourceUri, pickedDomains)) {
+                                return true;
+                            }
+                            return false;
+                        }
+                    }
+                ],
+                cancelButton: {
+                    run: () => false
+                }
+            });
+            return result;
+        }
+    }
+};
+OpenerValidatorContributions = ( __decorate([
+    ( __param(0, IOpenerService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, IProductService)),
+    ( __param(4, IQuickInputService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IClipboardService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IAuthenticationService)),
+    ( __param(10, IWorkspaceContextService)),
+    ( __param(11, IConfigurationService)),
+    ( __param(12, IWorkspaceTrustManagementService))
+], OpenerValidatorContributions));
+const rLocalhost = /^localhost(:\d+)?$/i;
+const r127 = /^127.0.0.1(:\d+)?$/;
+function isLocalhostAuthority(authority) {
+    return rLocalhost.test(authority) || r127.test(authority);
+}
+function normalizeURL(url) {
+    const caseInsensitiveAuthorities = ['github.com'];
+    try {
+        const parsed = typeof url === 'string' ? ( URI.parse(url, true)) : url;
+        if (caseInsensitiveAuthorities.includes(parsed.authority)) {
+            return ( parsed.with({ path: parsed.path.toLowerCase() }).toString(true));
+        }
+        else {
+            return ( parsed.toString(true));
+        }
+    }
+    catch {
+        return ( url.toString());
+    }
+}
+function isURLDomainTrusted(url, trustedDomains) {
+    url = ( URI.parse(normalizeURL(url)));
+    trustedDomains = ( trustedDomains.map(normalizeURL));
+    if (isLocalhostAuthority(url.authority)) {
+        return true;
+    }
+    for (let i = 0; i < trustedDomains.length; i++) {
+        if (trustedDomains[i] === '*') {
+            return true;
+        }
+        if (testUrlMatchesGlob(url, trustedDomains[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export { OpenerValidatorContributions, isURLDomainTrusted };

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

@@ -0,0 +1,67 @@
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2, MenuRegistry, MenuId, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { IURLService } from 'vscode/vscode/vs/platform/url/common/url';
+import { Extensions, registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { ExternalUriResolverContribution } from './externalUriResolver.js';
+import { manageTrustedDomainSettingsCommand } from './trustedDomains.js';
+import { TrustedDomainsFileSystemProvider } from './trustedDomainsFileSystemProvider.js';
+import { OpenerValidatorContributions } from './trustedDomainsValidator.js';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { workbenchConfigurationNodeBase } from 'vscode/vscode/vs/workbench/common/configuration';
+
+class OpenUrlAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.url.openUrl',
+            title: ( localize2WithPath('vs/workbench/contrib/url/browser/url.contribution', 'openUrl', 'Open URL')),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const urlService = accessor.get(IURLService);
+        return quickInputService.input({ prompt: ( localizeWithPath(
+            'vs/workbench/contrib/url/browser/url.contribution',
+            'urlToOpen',
+            "URL to open"
+        )) }).then(input => {
+            if (input) {
+                const uri = ( URI.parse(input));
+                urlService.open(uri, { originalUrl: input });
+            }
+        });
+    }
+}
+registerAction2(OpenUrlAction);
+CommandsRegistry.registerCommand(manageTrustedDomainSettingsCommand);
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: manageTrustedDomainSettingsCommand.id,
+        title: manageTrustedDomainSettingsCommand.description.description
+    }
+});
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(OpenerValidatorContributions, 3 );
+registerWorkbenchContribution2(TrustedDomainsFileSystemProvider.ID, TrustedDomainsFileSystemProvider, 2 );
+registerWorkbenchContribution2(ExternalUriResolverContribution.ID, ExternalUriResolverContribution, 2 );
+const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
+configurationRegistry.registerConfiguration({
+    ...workbenchConfigurationNodeBase,
+    properties: {
+        'workbench.trustedDomains.promptInTrustedWorkspace': {
+            scope: 1 ,
+            type: 'boolean',
+            default: false,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/url/browser/url.contribution',
+                'workbench.trustedDomains.promptInTrustedWorkspace',
+                "When enabled, trusted domain prompts will appear when opening links in trusted workspaces."
+            ))
+        }
+    }
+});

package/vscode/src/vs/workbench/services/quickinput/browser/quickInputService.js

@@ -0,0 +1,39 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { QuickInputService as QuickInputService$1 } from 'vscode/vscode/vs/platform/quickinput/browser/quickInputService';
+import 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+import { InQuickPickContextKey } from 'vscode/vscode/vs/workbench/browser/quickaccess';
+
+let QuickInputService = class QuickInputService extends QuickInputService$1 {
+    constructor(configurationService, instantiationService, keybindingService, contextKeyService, themeService, layoutService) {
+        super(instantiationService, contextKeyService, themeService, layoutService, configurationService);
+        this.keybindingService = keybindingService;
+        this.inQuickInputContext = InQuickPickContextKey.bindTo(this.contextKeyService);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.onShow(() => this.inQuickInputContext.set(true)));
+        this._register(this.onHide(() => this.inQuickInputContext.set(false)));
+    }
+    createController() {
+        return super.createController(this.layoutService, {
+            ignoreFocusOut: () => !this.configurationService.getValue('workbench.quickOpen.closeOnFocusLost'),
+            backKeybindingLabel: () => this.keybindingService.lookupKeybinding('workbench.action.quickInputBack')?.getLabel() || undefined,
+        });
+    }
+};
+QuickInputService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, ILayoutService))
+], QuickInputService));
+
+export { QuickInputService };