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

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

@@ -1,137 +0,0 @@
-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

@@ -1,205 +0,0 @@
-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 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.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

@@ -1,67 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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 { 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 };