@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalProfileQuickpick.js

@@ -0,0 +1,312 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { getUriClasses, getColorClass, createColorStyleElement } from './terminalIcon.js';
+import { configureTerminalProfileIcon } from './terminalIcons.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { ITerminalProfileService, ITerminalProfileResolverService } from '../common/terminal.js';
+import { getIconRegistry } from '../../../../platform/theme/common/iconRegistry.js';
+import { basename } from '../../../../base/common/path.js';
+import { Severity, INotificationService } from '../../../../platform/notification/common/notification.js';
+let TerminalProfileQuickpick = class TerminalProfileQuickpick {
+    constructor(_terminalProfileService, _terminalProfileResolverService, _configurationService, _quickInputService, _themeService, _notificationService) {
+        this._terminalProfileService = _terminalProfileService;
+        this._terminalProfileResolverService = _terminalProfileResolverService;
+        this._configurationService = _configurationService;
+        this._quickInputService = _quickInputService;
+        this._themeService = _themeService;
+        this._notificationService = _notificationService;
+    }
+    async showAndGetResult(type) {
+        const platformKey = await this._terminalProfileService.getPlatformKey();
+        const profilesKey = "terminal.integrated.profiles."  + platformKey;
+        const result = await this._createAndShow(type);
+        const defaultProfileKey = `${"terminal.integrated.defaultProfile." }${platformKey}`;
+        if (!result) {
+            return;
+        }
+        if (type === 'setDefault') {
+            if ('command' in result.profile) {
+                return;
+            }
+            else if ('id' in result.profile) {
+                await this._configurationService.updateValue(defaultProfileKey, result.profile.title, 2 );
+                return {
+                    config: {
+                        extensionIdentifier: result.profile.extensionIdentifier,
+                        id: result.profile.id,
+                        title: result.profile.title,
+                        options: {
+                            color: result.profile.color,
+                            icon: result.profile.icon
+                        }
+                    },
+                    keyMods: result.keyMods
+                };
+            }
+            if ('isAutoDetected' in result.profile) {
+                const profilesConfig = await this._configurationService.getValue(profilesKey);
+                if (typeof profilesConfig === 'object') {
+                    const newProfile = {
+                        path: result.profile.path
+                    };
+                    if (result.profile.args) {
+                        newProfile.args = result.profile.args;
+                    }
+                    profilesConfig[result.profile.profileName] = newProfile;
+                }
+                await this._configurationService.updateValue(profilesKey, profilesConfig, 2 );
+            }
+            await this._configurationService.updateValue(defaultProfileKey, result.profileName, 2 );
+        }
+        else if (type === 'createInstance') {
+            if ('id' in result.profile) {
+                return {
+                    config: {
+                        extensionIdentifier: result.profile.extensionIdentifier,
+                        id: result.profile.id,
+                        title: result.profile.title,
+                        options: {
+                            icon: result.profile.icon,
+                            color: result.profile.color,
+                        }
+                    },
+                    keyMods: result.keyMods
+                };
+            }
+            else {
+                return { config: result.profile, keyMods: result.keyMods };
+            }
+        }
+        return 'profileName' in result.profile ? result.profile.profileName : result.profile.title;
+    }
+    async _createAndShow(type) {
+        const platformKey = await this._terminalProfileService.getPlatformKey();
+        const profiles = this._terminalProfileService.availableProfiles;
+        const profilesKey = "terminal.integrated.profiles."  + platformKey;
+        const defaultProfileName = this._terminalProfileService.getDefaultProfileName();
+        let keyMods;
+        const options = {
+            placeHolder: type === 'createInstance' ? ( localizeWithPath(
+                'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                'terminal.integrated.selectProfileToCreate',
+                "Select the terminal profile to create"
+            )) : ( localizeWithPath(
+                'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                'terminal.integrated.chooseDefaultProfile',
+                "Select your default terminal profile"
+            )),
+            onDidTriggerItemButton: async (context) => {
+                if (!(await this._isProfileSafe(context.item.profile))) {
+                    return;
+                }
+                if ('command' in context.item.profile) {
+                    return;
+                }
+                if ('id' in context.item.profile) {
+                    return;
+                }
+                const configProfiles = this._configurationService.getValue("terminal.integrated.profiles."  + platformKey);
+                const existingProfiles = !!configProfiles ? ( Object.keys(configProfiles)) : [];
+                const name = await this._quickInputService.input({
+                    prompt: ( localizeWithPath(
+                        'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                        'enterTerminalProfileName',
+                        "Enter terminal profile name"
+                    )),
+                    value: context.item.profile.profileName,
+                    validateInput: async (input) => {
+                        if (existingProfiles.includes(input)) {
+                            return ( localizeWithPath(
+                                'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                                'terminalProfileAlreadyExists',
+                                "A terminal profile already exists with that name"
+                            ));
+                        }
+                        return undefined;
+                    }
+                });
+                if (!name) {
+                    return;
+                }
+                const newConfigValue = { ...configProfiles };
+                newConfigValue[name] = { path: context.item.profile.path };
+                if (context.item.profile.args) {
+                    newConfigValue[name].args = context.item.profile.args;
+                }
+                if (context.item.profile.env) {
+                    newConfigValue[name].env = context.item.profile.env;
+                }
+                await this._configurationService.updateValue(profilesKey, newConfigValue, 2 );
+            },
+            onKeyMods: mods => keyMods = mods
+        };
+        const quickPickItems = [];
+        const configProfiles = profiles.filter(e => !e.isAutoDetected);
+        const autoDetectedProfiles = profiles.filter(e => e.isAutoDetected);
+        if (configProfiles.length > 0) {
+            quickPickItems.push({ type: 'separator', label: ( localizeWithPath(
+                'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                'terminalProfiles',
+                "profiles"
+            )) });
+            quickPickItems.push(...this._sortProfileQuickPickItems(( configProfiles.map(e => this._createProfileQuickPickItem(e))), defaultProfileName));
+        }
+        quickPickItems.push({ type: 'separator', label: ( localizeWithPath(
+            'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+            'ICreateContributedTerminalProfileOptions',
+            "contributed"
+        )) });
+        const contributedProfiles = [];
+        for (const contributed of this._terminalProfileService.contributedProfiles) {
+            let icon;
+            if (typeof contributed.icon === 'string') {
+                if (contributed.icon.startsWith('$(')) {
+                    icon = ThemeIcon.fromString(contributed.icon);
+                }
+                else {
+                    icon = ThemeIcon.fromId(contributed.icon);
+                }
+            }
+            if (!icon || !getIconRegistry().getIcon(icon.id)) {
+                icon = this._terminalProfileResolverService.getDefaultIcon();
+            }
+            const uriClasses = getUriClasses(contributed, this._themeService.getColorTheme().type, true);
+            const colorClass = getColorClass(contributed);
+            const iconClasses = [];
+            if (uriClasses) {
+                iconClasses.push(...uriClasses);
+            }
+            if (colorClass) {
+                iconClasses.push(colorClass);
+            }
+            contributedProfiles.push({
+                label: `$(${icon.id}) ${contributed.title}`,
+                profile: {
+                    extensionIdentifier: contributed.extensionIdentifier,
+                    title: contributed.title,
+                    icon: contributed.icon,
+                    id: contributed.id,
+                    color: contributed.color
+                },
+                profileName: contributed.title,
+                iconClasses
+            });
+        }
+        if (contributedProfiles.length > 0) {
+            quickPickItems.push(...this._sortProfileQuickPickItems(contributedProfiles, defaultProfileName));
+        }
+        if (autoDetectedProfiles.length > 0) {
+            quickPickItems.push({ type: 'separator', label: ( localizeWithPath(
+                'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                'terminalProfiles.detected',
+                "detected"
+            )) });
+            quickPickItems.push(...this._sortProfileQuickPickItems(( autoDetectedProfiles.map(e => this._createProfileQuickPickItem(e))), defaultProfileName));
+        }
+        const colorStyleDisposable = createColorStyleElement(this._themeService.getColorTheme());
+        const result = await this._quickInputService.pick(quickPickItems, options);
+        colorStyleDisposable.dispose();
+        if (!result) {
+            return undefined;
+        }
+        if (!(await this._isProfileSafe(result.profile))) {
+            return undefined;
+        }
+        if (keyMods) {
+            result.keyMods = keyMods;
+        }
+        return result;
+    }
+    async _isProfileSafe(profile) {
+        const isUnsafePath = 'isUnsafePath' in profile && profile.isUnsafePath;
+        const requiresUnsafePath = 'requiresUnsafePath' in profile && profile.requiresUnsafePath;
+        if (!isUnsafePath && !requiresUnsafePath) {
+            return true;
+        }
+        return await ( new Promise(r => {
+            const unsafePaths = [];
+            if (isUnsafePath) {
+                unsafePaths.push(profile.path);
+            }
+            if (requiresUnsafePath) {
+                unsafePaths.push(requiresUnsafePath);
+            }
+            const handle = this._notificationService.prompt(Severity.Warning, ( localizeWithPath(
+                'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                'unsafePathWarning',
+                'This terminal profile uses a potentially unsafe path that can be modified by another user: {0}. Are you sure you want to use it?',
+                `"${unsafePaths.join(',')}"`
+            )), [{
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                        'yes',
+                        'Yes'
+                    )),
+                    run: () => r(true)
+                }, {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                        'cancel',
+                        'Cancel'
+                    )),
+                    run: () => r(false)
+                }]);
+            handle.onDidClose(() => r(false));
+        }));
+    }
+    _createProfileQuickPickItem(profile) {
+        const buttons = [{
+                iconClass: ThemeIcon.asClassName(configureTerminalProfileIcon),
+                tooltip: ( localizeWithPath(
+                    'vs/workbench/contrib/terminal/browser/terminalProfileQuickpick',
+                    'createQuickLaunchProfile',
+                    "Configure Terminal Profile"
+                ))
+            }];
+        const icon = (profile.icon && ThemeIcon.isThemeIcon(profile.icon)) ? profile.icon : Codicon.terminal;
+        const label = `$(${icon.id}) ${profile.profileName}`;
+        const friendlyPath = profile.isFromPath ? basename(profile.path) : profile.path;
+        const colorClass = getColorClass(profile);
+        const iconClasses = [];
+        if (colorClass) {
+            iconClasses.push(colorClass);
+        }
+        if (profile.args) {
+            if (typeof profile.args === 'string') {
+                return { label, description: `${profile.path} ${profile.args}`, profile, profileName: profile.profileName, buttons, iconClasses };
+            }
+            const argsString = ( profile.args.map(e => {
+                if (e.includes(' ')) {
+                    return `"${e.replace(/"/g, '\\"')}"`;
+                }
+                return e;
+            })).join(' ');
+            return { label, description: `${friendlyPath} ${argsString}`, profile, profileName: profile.profileName, buttons, iconClasses };
+        }
+        return { label, description: friendlyPath, profile, profileName: profile.profileName, buttons, iconClasses };
+    }
+    _sortProfileQuickPickItems(items, defaultProfileName) {
+        return items.sort((a, b) => {
+            if (b.profileName === defaultProfileName) {
+                return 1;
+            }
+            if (a.profileName === defaultProfileName) {
+                return -1;
+            }
+            return a.profileName.localeCompare(b.profileName);
+        });
+    }
+};
+TerminalProfileQuickpick = ( __decorate([
+    ( __param(0, ITerminalProfileService)),
+    ( __param(1, ITerminalProfileResolverService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IQuickInputService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, INotificationService))
+], TerminalProfileQuickpick));
+export { TerminalProfileQuickpick };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalProfileResolverService.js

@@ -0,0 +1,285 @@
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from '../../../../base/common/network.js';
+import '../../../../base/common/process.js';
+import { URI } from '../../../../base/common/uri.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+import '../../../../nls.js';
+import { parse, join } from '../../../../base/common/path.js';
+import '../../../../base/common/arrays.js';
+import '../../../../base/common/strings.js';
+import '../../../../base/common/resources.js';
+import '../../../services/configurationResolver/common/configurationResolver.js';
+import '../../../services/history/common/history.js';
+import { OS } from '../../../../base/common/platform.js';
+import '../../../../platform/terminal/common/terminal.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { getIconRegistry } from '../../../../platform/theme/common/iconRegistry.js';
+import '../../../../base/common/async.js';
+import { debounce } from '../../../../base/common/decorators.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { deepClone } from '../../../../base/common/objects.js';
+import { isUriComponents } from '../../../../platform/terminal/common/terminalProfiles.js';
+const generatedProfileName = 'Generated';
+class BaseTerminalProfileResolverService {
+    get defaultProfileName() { return this._defaultProfileName; }
+    constructor(_context, _configurationService, _configurationResolverService, _historyService, _logService, _terminalProfileService, _workspaceContextService, _remoteAgentService) {
+        this._context = _context;
+        this._configurationService = _configurationService;
+        this._configurationResolverService = _configurationResolverService;
+        this._historyService = _historyService;
+        this._logService = _logService;
+        this._terminalProfileService = _terminalProfileService;
+        this._workspaceContextService = _workspaceContextService;
+        this._remoteAgentService = _remoteAgentService;
+        this._iconRegistry = getIconRegistry();
+        if (this._remoteAgentService.getConnection()) {
+            this._remoteAgentService.getEnvironment().then(env => this._primaryBackendOs = env?.os || OS);
+        }
+        else {
+            this._primaryBackendOs = OS;
+        }
+        this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("terminal.integrated.defaultProfile.windows" ) ||
+                e.affectsConfiguration("terminal.integrated.defaultProfile.osx" ) ||
+                e.affectsConfiguration("terminal.integrated.defaultProfile.linux" )) {
+                this._refreshDefaultProfileName();
+            }
+        });
+        this._terminalProfileService.onDidChangeAvailableProfiles(() => this._refreshDefaultProfileName());
+    }
+    async _refreshDefaultProfileName() {
+        if (this._primaryBackendOs) {
+            this._defaultProfileName = (await this.getDefaultProfile({
+                remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority,
+                os: this._primaryBackendOs
+            }))?.profileName;
+        }
+    }
+    resolveIcon(shellLaunchConfig, os) {
+        if (shellLaunchConfig.icon) {
+            shellLaunchConfig.icon = this._getCustomIcon(shellLaunchConfig.icon) || this.getDefaultIcon();
+            return;
+        }
+        if (shellLaunchConfig.customPtyImplementation) {
+            shellLaunchConfig.icon = this.getDefaultIcon();
+            return;
+        }
+        if (shellLaunchConfig.executable) {
+            return;
+        }
+        const defaultProfile = this._getUnresolvedRealDefaultProfile(os);
+        if (defaultProfile) {
+            shellLaunchConfig.icon = defaultProfile.icon;
+        }
+        if (!shellLaunchConfig.icon) {
+            shellLaunchConfig.icon = this.getDefaultIcon();
+        }
+    }
+    getDefaultIcon(resource) {
+        return this._iconRegistry.getIcon(this._configurationService.getValue("terminal.integrated.tabs.defaultIcon" , { resource })) || Codicon.terminal;
+    }
+    async resolveShellLaunchConfig(shellLaunchConfig, options) {
+        let resolvedProfile;
+        if (shellLaunchConfig.executable) {
+            resolvedProfile = await this._resolveProfile({
+                path: shellLaunchConfig.executable,
+                args: shellLaunchConfig.args,
+                profileName: generatedProfileName,
+                isDefault: false
+            }, options);
+        }
+        else {
+            resolvedProfile = await this.getDefaultProfile(options);
+        }
+        shellLaunchConfig.executable = resolvedProfile.path;
+        shellLaunchConfig.args = resolvedProfile.args;
+        if (resolvedProfile.env) {
+            if (shellLaunchConfig.env) {
+                shellLaunchConfig.env = { ...shellLaunchConfig.env, ...resolvedProfile.env };
+            }
+            else {
+                shellLaunchConfig.env = resolvedProfile.env;
+            }
+        }
+        const resource = shellLaunchConfig === undefined || typeof shellLaunchConfig.cwd === 'string' ? undefined : shellLaunchConfig.cwd;
+        shellLaunchConfig.icon = this._getCustomIcon(shellLaunchConfig.icon)
+            || this._getCustomIcon(resolvedProfile.icon)
+            || this.getDefaultIcon(resource);
+        if (resolvedProfile.overrideName) {
+            shellLaunchConfig.name = resolvedProfile.profileName;
+        }
+        shellLaunchConfig.color = shellLaunchConfig.color
+            || resolvedProfile.color
+            || this._configurationService.getValue("terminal.integrated.tabs.defaultColor" , { resource });
+        if (shellLaunchConfig.useShellEnvironment === undefined) {
+            shellLaunchConfig.useShellEnvironment = this._configurationService.getValue("terminal.integrated.inheritEnv" );
+        }
+    }
+    async getDefaultShell(options) {
+        return (await this.getDefaultProfile(options)).path;
+    }
+    async getDefaultShellArgs(options) {
+        return (await this.getDefaultProfile(options)).args || [];
+    }
+    async getDefaultProfile(options) {
+        return this._resolveProfile(await this._getUnresolvedDefaultProfile(options), options);
+    }
+    getEnvironment(remoteAuthority) {
+        return this._context.getEnvironment(remoteAuthority);
+    }
+    _getCustomIcon(icon) {
+        if (!icon) {
+            return undefined;
+        }
+        if (typeof icon === 'string') {
+            return ThemeIcon.fromId(icon);
+        }
+        if (ThemeIcon.isThemeIcon(icon)) {
+            return icon;
+        }
+        if (URI.isUri(icon) || isUriComponents(icon)) {
+            return URI.revive(icon);
+        }
+        if (typeof icon === 'object' && 'light' in icon && 'dark' in icon) {
+            const castedIcon = icon;
+            if ((URI.isUri(castedIcon.light) || isUriComponents(castedIcon.light)) && (URI.isUri(castedIcon.dark) || isUriComponents(castedIcon.dark))) {
+                return { light: URI.revive(castedIcon.light), dark: URI.revive(castedIcon.dark) };
+            }
+        }
+        return undefined;
+    }
+    async _getUnresolvedDefaultProfile(options) {
+        if (options.allowAutomationShell) {
+            const automationShellProfile = this._getUnresolvedAutomationShellProfile(options);
+            if (automationShellProfile) {
+                return automationShellProfile;
+            }
+        }
+        await this._terminalProfileService.profilesReady;
+        const defaultProfile = this._getUnresolvedRealDefaultProfile(options.os);
+        if (defaultProfile) {
+            return this._setIconForAutomation(options, defaultProfile);
+        }
+        return this._setIconForAutomation(options, await this._getUnresolvedFallbackDefaultProfile(options));
+    }
+    _setIconForAutomation(options, profile) {
+        if (options.allowAutomationShell) {
+            const profileClone = deepClone(profile);
+            profileClone.icon = Codicon.tools;
+            return profileClone;
+        }
+        return profile;
+    }
+    _getUnresolvedRealDefaultProfile(os) {
+        return this._terminalProfileService.getDefaultProfile(os);
+    }
+    async _getUnresolvedFallbackDefaultProfile(options) {
+        const executable = await this._context.getDefaultSystemShell(options.remoteAuthority, options.os);
+        if (options.os === OS) {
+            let existingProfile = this._terminalProfileService.availableProfiles.find(e => parse(e.path).name === parse(executable).name);
+            if (existingProfile) {
+                if (options.allowAutomationShell) {
+                    existingProfile = deepClone(existingProfile);
+                    existingProfile.icon = Codicon.tools;
+                }
+                return existingProfile;
+            }
+        }
+        let args;
+        if (options.os === 2  && parse(executable).name.match(/(zsh|bash)/)) {
+            args = ['--login'];
+        }
+        else {
+            args = [];
+        }
+        const icon = this._guessProfileIcon(executable);
+        return {
+            profileName: generatedProfileName,
+            path: executable,
+            args,
+            icon,
+            isDefault: false
+        };
+    }
+    _getUnresolvedAutomationShellProfile(options) {
+        const automationProfile = this._configurationService.getValue(`terminal.integrated.automationProfile.${this._getOsKey(options.os)}`);
+        if (this._isValidAutomationProfile(automationProfile, options.os)) {
+            automationProfile.icon = this._getCustomIcon(automationProfile.icon) || Codicon.tools;
+            return automationProfile;
+        }
+        return undefined;
+    }
+    async _resolveProfile(profile, options) {
+        const env = await this._context.getEnvironment(options.remoteAuthority);
+        if (options.os === 1 ) {
+            const isWoW64 = !!env.hasOwnProperty('PROCESSOR_ARCHITEW6432');
+            const windir = env.windir;
+            if (!isWoW64 && windir) {
+                const sysnativePath = join(windir, 'Sysnative').replace(/\//g, '\\').toLowerCase();
+                if (profile.path && profile.path.toLowerCase().indexOf(sysnativePath) === 0) {
+                    profile.path = join(windir, 'System32', profile.path.substr(sysnativePath.length + 1));
+                }
+            }
+            if (profile.path) {
+                profile.path = profile.path.replace(/\//g, '\\');
+            }
+        }
+        const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot(options.remoteAuthority ? Schemas.vscodeRemote : Schemas.file);
+        const lastActiveWorkspace = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
+        profile.path = await this._resolveVariables(profile.path, env, lastActiveWorkspace);
+        if (profile.args) {
+            if (typeof profile.args === 'string') {
+                profile.args = await this._resolveVariables(profile.args, env, lastActiveWorkspace);
+            }
+            else {
+                profile.args = await Promise.all(( profile.args.map(arg => this._resolveVariables(arg, env, lastActiveWorkspace))));
+            }
+        }
+        return profile;
+    }
+    async _resolveVariables(value, env, lastActiveWorkspace) {
+        try {
+            value = await this._configurationResolverService.resolveWithEnvironment(env, lastActiveWorkspace, value);
+        }
+        catch (e) {
+            this._logService.error(`Could not resolve shell`, e);
+        }
+        return value;
+    }
+    _getOsKey(os) {
+        switch (os) {
+            case 3 : return 'linux';
+            case 2 : return 'osx';
+            case 1 : return 'windows';
+        }
+    }
+    _guessProfileIcon(shell) {
+        const file = parse(shell).name;
+        switch (file) {
+            case 'bash':
+                return Codicon.terminalBash;
+            case 'pwsh':
+            case 'powershell':
+                return Codicon.terminalPowershell;
+            case 'tmux':
+                return Codicon.terminalTmux;
+            case 'cmd':
+                return Codicon.terminalCmd;
+            default:
+                return undefined;
+        }
+    }
+    _isValidAutomationProfile(profile, os) {
+        if (profile === null || profile === undefined || typeof profile !== 'object') {
+            return false;
+        }
+        if ('path' in profile && typeof profile.path === 'string') {
+            return true;
+        }
+        return false;
+    }
+}
+BaseTerminalProfileResolverService.__decorator = ( __decorate([
+    debounce(200)
+], BaseTerminalProfileResolverService.prototype, "_refreshDefaultProfileName", null));
+export { BaseTerminalProfileResolverService };