@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/contrib/terminal/common/terminalEnvironment.js

@@ -1,272 +0,0 @@
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { sanitizeProcessEnvironment } from '../../../../base/common/processes.js';
-import { isWindows, language } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { escapeNonWindowsPath, sanitizeCwd } from '../../../../platform/terminal/common/terminalEnvironment.js';
-import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
-function mergeEnvironments(parent, other) {
-    if (!other) {
-        return;
-    }
-    if (isWindows) {
-        for (const configKey in other) {
-            let actualKey = configKey;
-            for (const envKey in parent) {
-                if (configKey.toLowerCase() === envKey.toLowerCase()) {
-                    actualKey = envKey;
-                    break;
-                }
-            }
-            const value = other[configKey];
-            if (value !== undefined) {
-                _mergeEnvironmentValue(parent, actualKey, value);
-            }
-        }
-    }
-    else {
-        ( Object.keys(other)).forEach((key) => {
-            const value = other[key];
-            if (value !== undefined) {
-                _mergeEnvironmentValue(parent, key, value);
-            }
-        });
-    }
-}
-function _mergeEnvironmentValue(env, key, value) {
-    if (typeof value === 'string') {
-        env[key] = value;
-    }
-    else {
-        delete env[key];
-    }
-}
-function addTerminalEnvironmentKeys(env, version, locale, detectLocale) {
-    env['TERM_PROGRAM'] = 'vscode';
-    if (version) {
-        env['TERM_PROGRAM_VERSION'] = version;
-    }
-    if (shouldSetLangEnvVariable(env, detectLocale)) {
-        env['LANG'] = getLangEnvVariable(locale);
-    }
-    env['COLORTERM'] = 'truecolor';
-}
-function mergeNonNullKeys(env, other) {
-    if (!other) {
-        return;
-    }
-    for (const key of ( Object.keys(other))) {
-        const value = other[key];
-        if (value !== undefined && value !== null) {
-            env[key] = value;
-        }
-    }
-}
-async function resolveConfigurationVariables(variableResolver, env) {
-    await Promise.all(( Object.entries(env).map(async ([key, value]) => {
-        if (typeof value === 'string') {
-            try {
-                env[key] = await variableResolver(value);
-            }
-            catch (e) {
-                env[key] = value;
-            }
-        }
-    })));
-    return env;
-}
-function shouldSetLangEnvVariable(env, detectLocale) {
-    if (detectLocale === 'on') {
-        return true;
-    }
-    if (detectLocale === 'auto') {
-        const lang = env['LANG'];
-        return !lang || (lang.search(/\.UTF\-8$/) === -1 && lang.search(/\.utf8$/) === -1 && lang.search(/\.euc.+/) === -1);
-    }
-    return false;
-}
-function getLangEnvVariable(locale) {
-    const parts = locale ? locale.split('-') : [];
-    const n = parts.length;
-    if (n === 0) {
-        return 'en_US.UTF-8';
-    }
-    if (n === 1) {
-        const languageVariants = {
-            af: 'ZA',
-            am: 'ET',
-            be: 'BY',
-            bg: 'BG',
-            ca: 'ES',
-            cs: 'CZ',
-            da: 'DK',
-            de: 'DE',
-            el: 'GR',
-            en: 'US',
-            es: 'ES',
-            et: 'EE',
-            eu: 'ES',
-            fi: 'FI',
-            fr: 'FR',
-            he: 'IL',
-            hr: 'HR',
-            hu: 'HU',
-            hy: 'AM',
-            is: 'IS',
-            it: 'IT',
-            ja: 'JP',
-            kk: 'KZ',
-            ko: 'KR',
-            lt: 'LT',
-            nl: 'NL',
-            no: 'NO',
-            pl: 'PL',
-            pt: 'BR',
-            ro: 'RO',
-            ru: 'RU',
-            sk: 'SK',
-            sl: 'SI',
-            sr: 'YU',
-            sv: 'SE',
-            tr: 'TR',
-            uk: 'UA',
-            zh: 'CN',
-        };
-        if (parts[0] in languageVariants) {
-            parts.push(languageVariants[parts[0]]);
-        }
-    }
-    else {
-        parts[1] = parts[1].toUpperCase();
-    }
-    return parts.join('_') + '.UTF-8';
-}
-async function getCwd(shell, userHome, variableResolver, root, customCwd, logService) {
-    if (shell.cwd) {
-        const unresolved = (typeof shell.cwd === 'object') ? shell.cwd.fsPath : shell.cwd;
-        const resolved = await _resolveCwd(unresolved, variableResolver);
-        return sanitizeCwd(resolved || unresolved);
-    }
-    let cwd;
-    if (!shell.ignoreConfigurationCwd && customCwd) {
-        if (variableResolver) {
-            customCwd = await _resolveCwd(customCwd, variableResolver, logService);
-        }
-        if (customCwd) {
-            if (path.isAbsolute(customCwd)) {
-                cwd = customCwd;
-            }
-            else if (root) {
-                cwd = path.join(root.fsPath, customCwd);
-            }
-        }
-    }
-    if (!cwd) {
-        cwd = root ? root.fsPath : userHome || '';
-    }
-    return sanitizeCwd(cwd);
-}
-async function _resolveCwd(cwd, variableResolver, logService) {
-    if (variableResolver) {
-        try {
-            return await variableResolver(cwd);
-        }
-        catch (e) {
-            logService?.error('Could not resolve terminal cwd', e);
-            return undefined;
-        }
-    }
-    return cwd;
-}
-function createVariableResolver(lastActiveWorkspace, env, configurationResolverService) {
-    if (!configurationResolverService) {
-        return undefined;
-    }
-    return (str) => configurationResolverService.resolveWithEnvironment(env, lastActiveWorkspace, str);
-}
-async function createTerminalEnvironment(shellLaunchConfig, envFromConfig, variableResolver, version, detectLocale, baseEnv) {
-    const env = {};
-    if (shellLaunchConfig.strictEnv) {
-        mergeNonNullKeys(env, shellLaunchConfig.env);
-    }
-    else {
-        mergeNonNullKeys(env, baseEnv);
-        const allowedEnvFromConfig = { ...envFromConfig };
-        if (variableResolver) {
-            if (allowedEnvFromConfig) {
-                await resolveConfigurationVariables(variableResolver, allowedEnvFromConfig);
-            }
-            if (shellLaunchConfig.env) {
-                await resolveConfigurationVariables(variableResolver, shellLaunchConfig.env);
-            }
-        }
-        sanitizeProcessEnvironment(env, 'VSCODE_IPC_HOOK_CLI');
-        mergeEnvironments(env, allowedEnvFromConfig);
-        mergeEnvironments(env, shellLaunchConfig.env);
-        addTerminalEnvironmentKeys(env, version, language, detectLocale);
-    }
-    return env;
-}
-async function preparePathForShell(resource, executable, title, shellType, backend, os, isWindowsFrontend = isWindows) {
-    let originalPath;
-    if (isString(resource)) {
-        originalPath = resource;
-    }
-    else {
-        originalPath = resource.fsPath;
-        if (isWindowsFrontend && os !== 1 ) {
-            originalPath = originalPath.replace(/\\/g, '\/');
-        }
-        else if (!isWindowsFrontend && os === 1 ) {
-            originalPath = originalPath.replace(/\//g, '\\');
-        }
-    }
-    if (!executable) {
-        return originalPath;
-    }
-    const hasSpace = originalPath.includes(' ');
-    const hasParens = originalPath.includes('(') || originalPath.includes(')');
-    const pathBasename = path.basename(executable, '.exe');
-    const isPowerShell = pathBasename === 'pwsh' ||
-        title === 'pwsh' ||
-        pathBasename === 'powershell' ||
-        title === 'powershell';
-    if (isPowerShell && (hasSpace || originalPath.includes('\''))) {
-        return `& '${originalPath.replace(/'/g, '\'\'')}'`;
-    }
-    if (hasParens && isPowerShell) {
-        return `& '${originalPath}'`;
-    }
-    if (os === 1 ) {
-        if (shellType !== undefined) {
-            if (shellType === "gitbash" ) {
-                return escapeNonWindowsPath(originalPath.replace(/\\/g, '/'));
-            }
-            else if (shellType === "wsl" ) {
-                return backend?.getWslPath(originalPath, 'win-to-unix') || originalPath;
-            }
-            else if (hasSpace) {
-                return `"${originalPath}"`;
-            }
-            return originalPath;
-        }
-        const lowerExecutable = executable.toLowerCase();
-        if (lowerExecutable.includes('wsl') || (lowerExecutable.includes('bash.exe') && !lowerExecutable.toLowerCase().includes('git'))) {
-            return backend?.getWslPath(originalPath, 'win-to-unix') || originalPath;
-        }
-        else if (hasSpace) {
-            return `"${originalPath}"`;
-        }
-        return originalPath;
-    }
-    return escapeNonWindowsPath(originalPath);
-}
-function getWorkspaceForTerminal(cwd, workspaceContextService, historyService) {
-    const cwdUri = typeof cwd === 'string' ? ( URI.parse(cwd)) : cwd;
-    let workspaceFolder = cwdUri ? workspaceContextService.getWorkspaceFolder(cwdUri) ?? undefined : undefined;
-    if (!workspaceFolder) {
-        const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot();
-        workspaceFolder = activeWorkspaceRootUri ? workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
-    }
-    return workspaceFolder;
-}
-export { addTerminalEnvironmentKeys, createTerminalEnvironment, createVariableResolver, getCwd, getLangEnvVariable, getWorkspaceForTerminal, mergeEnvironments, preparePathForShell, shouldSetLangEnvVariable };

package/vscode/src/vs/workbench/contrib/terminal/common/terminalStrings.js

@@ -1,93 +0,0 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-const terminalStrings = {
-    terminal: ( localize('terminal', "Terminal")),
-    new: ( localize('terminal.new', "New Terminal")),
-    doNotShowAgain: ( localize('doNotShowAgain', 'Do Not Show Again')),
-    currentSessionCategory: ( localize('currentSessionCategory', 'current session')),
-    previousSessionCategory: ( localize('previousSessionCategory', 'previous session')),
-    actionCategory: {
-        value: ( localize('terminalCategory', "Terminal")),
-        original: 'Terminal'
-    },
-    focus: {
-        value: ( localize('workbench.action.terminal.focus', "Focus Terminal")),
-        original: 'Focus Terminal'
-    },
-    focusAndHideAccessibleBuffer: {
-        value: ( localize(
-            'workbench.action.terminal.focusAndHideAccessibleBuffer',
-            "Focus Terminal and Hide Accessible Buffer"
-        )),
-        original: 'Focus Terminal and Hide Accessible Buffer'
-    },
-    kill: {
-        value: ( localize('killTerminal', "Kill Terminal")),
-        original: 'Kill Terminal',
-        short: ( localize('killTerminal.short', "Kill")),
-    },
-    moveToEditor: {
-        value: ( localize('moveToEditor', "Move Terminal into Editor Area")),
-        original: 'Move Terminal into Editor Area',
-    },
-    moveToTerminalPanel: {
-        value: ( localize(
-            'workbench.action.terminal.moveToTerminalPanel',
-            "Move Terminal into Panel"
-        )),
-        original: 'Move Terminal into Panel'
-    },
-    changeIcon: {
-        value: ( localize('workbench.action.terminal.changeIcon', "Change Icon...")),
-        original: 'Change Icon...'
-    },
-    changeColor: {
-        value: ( localize('workbench.action.terminal.changeColor', "Change Color...")),
-        original: 'Change Color...'
-    },
-    split: {
-        value: ( localize('splitTerminal', "Split Terminal")),
-        original: 'Split Terminal',
-        short: ( localize('splitTerminal.short', "Split")),
-    },
-    unsplit: {
-        value: ( localize('unsplitTerminal', "Unsplit Terminal")),
-        original: 'Unsplit Terminal'
-    },
-    rename: {
-        value: ( localize('workbench.action.terminal.rename', "Rename...")),
-        original: 'Rename...'
-    },
-    toggleSizeToContentWidth: {
-        value: ( localize(
-            'workbench.action.terminal.sizeToContentWidthInstance',
-            "Toggle Size to Content Width"
-        )),
-        original: 'Toggle Size to Content Width'
-    },
-    focusHover: {
-        value: ( localize('workbench.action.terminal.focusHover', "Focus Hover")),
-        original: 'Focus Hover'
-    },
-    sendSequence: {
-        value: ( localize(
-            'workbench.action.terminal.sendSequence',
-            "Send Custom Sequence To Terminal"
-        )),
-        original: 'Send Custom Sequence To Terminal'
-    },
-    newWithCwd: {
-        value: ( localize(
-            'workbench.action.terminal.newWithCwd',
-            "Create New Terminal Starting in a Custom Working Directory"
-        )),
-        original: 'Create New Terminal Starting in a Custom Working Directory'
-    },
-    renameWithArgs: {
-        value: ( localize(
-            'workbench.action.terminal.renameWithArg',
-            "Rename the Currently Active Terminal"
-        )),
-        original: 'Rename the Currently Active Terminal'
-    }
-};
-export { terminalStrings };

package/vscode/src/vs/workbench/contrib/terminal/electron-sandbox/terminalProfileResolverService.js

@@ -1,42 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ITerminalLogService } from '../../../../platform/terminal/common/terminal.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { ITerminalInstanceService } from '../browser/terminal.js';
-import { BaseTerminalProfileResolverService } from '../browser/terminalProfileResolverService.js';
-import { ITerminalProfileService } from '../common/terminal.js';
-import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
-import { IHistoryService } from '../../../services/history/common/history.js';
-import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
-let ElectronTerminalProfileResolverService = class ElectronTerminalProfileResolverService extends BaseTerminalProfileResolverService {
-    constructor(configurationResolverService, configurationService, historyService, logService, workspaceContextService, terminalProfileService, remoteAgentService, terminalInstanceService) {
-        super({
-            getDefaultSystemShell: async (remoteAuthority, platform) => {
-                const backend = await terminalInstanceService.getBackend(remoteAuthority);
-                if (!backend) {
-                    throw new ErrorNoTelemetry(`Cannot get default system shell when there is no backend for remote authority '${remoteAuthority}'`);
-                }
-                return backend.getDefaultSystemShell(platform);
-            },
-            getEnvironment: async (remoteAuthority) => {
-                const backend = await terminalInstanceService.getBackend(remoteAuthority);
-                if (!backend) {
-                    throw new ErrorNoTelemetry(`Cannot get environment when there is no backend for remote authority '${remoteAuthority}'`);
-                }
-                return backend.getEnvironment();
-            }
-        }, configurationService, configurationResolverService, historyService, logService, terminalProfileService, workspaceContextService, remoteAgentService);
-    }
-};
-ElectronTerminalProfileResolverService = ( __decorate([
-    ( __param(0, IConfigurationResolverService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IHistoryService)),
-    ( __param(3, ITerminalLogService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, ITerminalProfileService)),
-    ( __param(6, IRemoteAgentService)),
-    ( __param(7, ITerminalInstanceService))
-], ElectronTerminalProfileResolverService));
-export { ElectronTerminalProfileResolverService };

package/vscode/src/vs/workbench/contrib/terminalContrib/accessibility/browser/bufferContentTracker.js

@@ -1,110 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ITerminalLogService } from '../../../../../platform/terminal/common/terminal.js';
-let BufferContentTracker = class BufferContentTracker {
-    get lines() { return this._lines; }
-    constructor(_xterm, _logService, _configurationService) {
-        this._xterm = _xterm;
-        this._logService = _logService;
-        this._configurationService = _configurationService;
-        this._priorEditorViewportLineCount = 0;
-        this._lines = [];
-        this.bufferToEditorLineMapping = ( new Map());
-    }
-    reset() {
-        this._lines = [];
-        this._lastCachedMarker = undefined;
-        this.update();
-    }
-    update() {
-        if (this._lastCachedMarker?.isDisposed) {
-            this._lines = [];
-            this._lastCachedMarker = undefined;
-        }
-        this._removeViewportContent();
-        this._updateCachedContent();
-        this._updateViewportContent();
-        this._lastCachedMarker = this._xterm.raw.registerMarker();
-        this._logService.debug('Buffer content tracker: set ', this._lines.length, ' lines');
-    }
-    _updateCachedContent() {
-        const buffer = this._xterm.raw.buffer.active;
-        const start = this._lastCachedMarker?.line ? this._lastCachedMarker.line - this._xterm.raw.rows + 1 : 0;
-        const end = buffer.baseY;
-        if (start < 0 || start > end) {
-            return;
-        }
-        const scrollback = this._configurationService.getValue("terminal.integrated.scrollback" );
-        const maxBufferSize = scrollback + this._xterm.raw.rows - 1;
-        const linesToAdd = end - start;
-        if (linesToAdd + this._lines.length > maxBufferSize) {
-            const numToRemove = linesToAdd + this._lines.length - maxBufferSize;
-            for (let i = 0; i < numToRemove; i++) {
-                this._lines.shift();
-            }
-            this._logService.debug('Buffer content tracker: removed ', numToRemove, ' lines from top of cached lines, now ', this._lines.length, ' lines');
-        }
-        const cachedLines = [];
-        let currentLine = '';
-        for (let i = start; i < end; i++) {
-            const line = buffer.getLine(i);
-            if (!line) {
-                continue;
-            }
-            this.bufferToEditorLineMapping.set(i, this._lines.length + cachedLines.length);
-            const isWrapped = buffer.getLine(i + 1)?.isWrapped;
-            currentLine += line.translateToString(!isWrapped);
-            if (currentLine && !isWrapped || i === (buffer.baseY + this._xterm.raw.rows - 1)) {
-                if (line.length) {
-                    cachedLines.push(currentLine);
-                    currentLine = '';
-                }
-            }
-        }
-        this._logService.debug('Buffer content tracker:', cachedLines.length, ' lines cached');
-        this._lines.push(...cachedLines);
-    }
-    _removeViewportContent() {
-        if (!this._lines.length) {
-            return;
-        }
-        let linesToRemove = this._priorEditorViewportLineCount;
-        let index = 1;
-        while (linesToRemove) {
-            this.bufferToEditorLineMapping.forEach((value, key) => { if (value === this._lines.length - index) {
-                this.bufferToEditorLineMapping.delete(key);
-            } });
-            this._lines.pop();
-            index++;
-            linesToRemove--;
-        }
-        this._logService.debug('Buffer content tracker: removed lines from viewport, now ', this._lines.length, ' lines cached');
-    }
-    _updateViewportContent() {
-        const buffer = this._xterm.raw.buffer.active;
-        this._priorEditorViewportLineCount = 0;
-        let currentLine = '';
-        for (let i = buffer.baseY; i < buffer.baseY + this._xterm.raw.rows; i++) {
-            const line = buffer.getLine(i);
-            if (!line) {
-                continue;
-            }
-            this.bufferToEditorLineMapping.set(i, this._lines.length);
-            const isWrapped = buffer.getLine(i + 1)?.isWrapped;
-            currentLine += line.translateToString(!isWrapped);
-            if (currentLine && !isWrapped || i === (buffer.baseY + this._xterm.raw.rows - 1)) {
-                if (currentLine.length) {
-                    this._priorEditorViewportLineCount++;
-                    this._lines.push(currentLine);
-                    currentLine = '';
-                }
-            }
-        }
-        this._logService.debug('Viewport content update complete, ', this._lines.length, ' lines in the viewport');
-    }
-};
-BufferContentTracker = ( __decorate([
-    ( __param(1, ITerminalLogService)),
-    ( __param(2, IConfigurationService))
-], BufferContentTracker));
-export { BufferContentTracker };