@opensumi/ide-terminal-next 3.7.2-next-1740052080.0 → 3.7.2-next-1740054042.0

package/lib/browser/terminal.environment.service.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalEnvironmentService = exports.ENVIRONMENT_VARIABLE_COLLECTIONS_KEY = void 0;
+const tslib_1 = require("tslib");
+const debounce_1 = tslib_1.__importDefault(require("lodash/debounce"));
+const throttle_1 = tslib_1.__importDefault(require("lodash/throttle"));
+const react_1 = tslib_1.__importDefault(require("react"));
+const di_1 = require("@opensumi/di");
+const ide_core_browser_1 = require("@opensumi/ide-core-browser");
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+const common_1 = require("@opensumi/ide-overlay/lib/common");
+const common_2 = require("@opensumi/ide-status-bar/lib/common");
+const common_3 = require("@opensumi/ide-workspace/lib/common");
+const common_4 = require("../common");
+const environmentVariable_1 = require("../common/environmentVariable");
+const environmentVariableCollection_1 = require("../common/environmentVariableCollection");
+const terminal_variable_1 = require("./component/terminal.variable");
+exports.ENVIRONMENT_VARIABLE_COLLECTIONS_KEY = 'terminal.integrated.environmentVariableCollections';
+const ENVIRONMENT_VARIABLE_CHANGED_STATUS = 'terminal.environmentVariableCollections.changed';
+let TerminalEnvironmentService = class TerminalEnvironmentService {
+    constructor() {
+        this.collections = new Map();
+        this._onDidChangeCollections = new ide_core_common_1.Emitter();
+    }
+    get onDidChangeCollections() {
+        return this._onDidChangeCollections.event;
+    }
+    async initEnvironmentVariableCollections() {
+        const serializedCollections = await this.storageService.getData(exports.ENVIRONMENT_VARIABLE_COLLECTIONS_KEY);
+        if (serializedCollections) {
+            try {
+                const collectionsJson = JSON.parse(serializedCollections);
+                collectionsJson.forEach((c) => {
+                    this.collections.set(c.extensionIdentifier, {
+                        persistent: true,
+                        map: (0, environmentVariable_1.deserializeEnvironmentVariableCollection)(c.collection),
+                    });
+                });
+            }
+            catch (err) {
+                this.logger.warn(`parse environment variable collection error: \n ${err.message}, data: \n ${serializedCollections}`);
+            }
+        }
+        this.mergedCollection = this.resolveMergedCollection();
+        this.previousMergedCollection = undefined;
+    }
+    set(extensionIdentifier, collection) {
+        this.collections.set(extensionIdentifier, collection);
+        this.updateCollections();
+    }
+    delete(extensionIdentifier) {
+        this.collections.delete(extensionIdentifier);
+        this.updateCollections();
+    }
+    async getProcessEnv() {
+        return (0, ide_core_common_1.raceTimeout)(this.terminalProcessService.getEnv(), 1000);
+    }
+    resolveMergedCollection() {
+        return new environmentVariableCollection_1.MergedEnvironmentVariableCollection(this.collections);
+    }
+    onDidClickStatusBarEntry(diff) {
+        this.dialogService
+            .warning(react_1.default.createElement(terminal_variable_1.TerminalVariable, { diff }), [
+            (0, ide_core_common_1.localize)('dialog.file.close'),
+            (0, ide_core_common_1.localize)('terminal.relaunch'),
+        ])
+            .then((res) => {
+            var _a;
+            if (res && res === (0, ide_core_common_1.localize)('terminal.relaunch')) {
+                this.commandService.executeCommand(ide_core_browser_1.TERMINAL_COMMANDS.RE_LAUNCH.id);
+                (_a = this.statusBarEntryAccessor) === null || _a === void 0 ? void 0 : _a.dispose();
+                this.statusBarEntryAccessor = undefined;
+            }
+        });
+    }
+    updateStatusBarMessage() {
+        var _a;
+        if (!this.mergedCollection) {
+            return;
+        }
+        const diff = (_a = this.previousMergedCollection) === null || _a === void 0 ? void 0 : _a.diff(this.mergedCollection);
+        if (!diff) {
+            return;
+        }
+        if (this.statusBarEntryAccessor) {
+            this.statusBarEntryAccessor.dispose();
+            this.statusBarEntryAccessor = undefined;
+        }
+        const changes = [];
+        this.mergedCollection.map.forEach((mutators, variable) => {
+            mutators.forEach((mutator) => changes.push((0, environmentVariable_1.mutatorTypeLabel)(mutator.type, mutator.value, variable)));
+        });
+        this.statusBarEntryAccessor = this.statusbarService.addElement(ENVIRONMENT_VARIABLE_CHANGED_STATUS, {
+            iconClass: (0, ide_core_browser_1.getIcon)('warning-circle'),
+            color: 'orange',
+            alignment: ide_core_browser_1.StatusBarAlignment.RIGHT,
+            tooltip: (0, ide_core_common_1.toMarkdownString)((0, ide_core_common_1.localize)('terminal.environment.changed') + '\n\n```\n' + changes.join('\n') + '\n```'),
+            onClick: () => this.onDidClickStatusBarEntry(diff),
+        });
+    }
+    notifyCollectionUpdates() {
+        this._onDidChangeCollections.fire(this.mergedCollection);
+        this.updateStatusBarMessage();
+    }
+    updateCollections() {
+        (0, throttle_1.default)(this.persistCollections.bind(this), 100)();
+        this.previousMergedCollection = this.mergedCollection;
+        this.mergedCollection = this.resolveMergedCollection();
+        (0, debounce_1.default)(this.notifyCollectionUpdates.bind(this), 1000)();
+    }
+    persistCollections() {
+        const collectionsJson = [];
+        this.collections.forEach((collection, extensionIdentifier) => {
+            if (collection.persistent) {
+                collectionsJson.push({
+                    extensionIdentifier,
+                    collection: (0, environmentVariable_1.serializeEnvironmentVariableCollection)(this.collections.get(extensionIdentifier).map),
+                });
+            }
+        });
+        const stringifiedJson = JSON.stringify(collectionsJson);
+        this.storageService.setData(exports.ENVIRONMENT_VARIABLE_COLLECTIONS_KEY, stringifiedJson);
+    }
+};
+exports.TerminalEnvironmentService = TerminalEnvironmentService;
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_3.IWorkspaceStorageService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalEnvironmentService.prototype, "storageService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_2.IStatusBarService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalEnvironmentService.prototype, "statusbarService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_4.ITerminalProcessPath),
+    tslib_1.__metadata("design:type", Object)
+], TerminalEnvironmentService.prototype, "terminalProcessService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.IDialogService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalEnvironmentService.prototype, "dialogService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(ide_core_common_1.CommandService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalEnvironmentService.prototype, "commandService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(ide_core_common_1.ILogger),
+    tslib_1.__metadata("design:type", Object)
+], TerminalEnvironmentService.prototype, "logger", void 0);
+exports.TerminalEnvironmentService = TerminalEnvironmentService = tslib_1.__decorate([
+    (0, di_1.Injectable)()
+], TerminalEnvironmentService);
+//# sourceMappingURL=terminal.environment.service.js.map

package/lib/browser/terminal.error.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalErrorService = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+const common_1 = require("../common");
+let TerminalErrorService = class TerminalErrorService {
+    constructor() {
+        this.errors = new Map();
+        this._onErrorsChangeEmitter = new ide_core_common_1.Emitter();
+        this.onErrorsChange = this._onErrorsChangeEmitter.event;
+        this.service.onError((error) => {
+            this.errors.set(error.id, error);
+            this._onErrorsChangeEmitter.fire();
+        });
+        this.service.onExit((event) => {
+            try {
+                const widget = this.view.getWidget(event.sessionId);
+                if (!widget.reuse) {
+                    this.view.removeWidget(event.sessionId);
+                }
+            }
+            catch (_e) {
+                /** nothing */
+            }
+        });
+        this.controller.onDidCloseTerminal((e) => {
+            this.errors.delete(e.id);
+            this._onErrorsChangeEmitter.fire();
+        });
+    }
+    async fix(clientId) {
+        const client = this.controller.findClientFromWidgetId(clientId);
+        if (client) {
+            await 0; // 使后面的 delete 发生在下一个 microTask 中，避免在迭代过程中修改 this.errors
+            this.errors.delete(clientId);
+            this._onErrorsChangeEmitter.fire();
+            client.reset();
+            return client.attached.promise;
+        }
+    }
+};
+exports.TerminalErrorService = TerminalErrorService;
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalErrorService.prototype, "service", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalController),
+    tslib_1.__metadata("design:type", Object)
+], TerminalErrorService.prototype, "controller", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalGroupViewService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalErrorService.prototype, "view", void 0);
+exports.TerminalErrorService = TerminalErrorService = tslib_1.__decorate([
+    (0, di_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], TerminalErrorService);
+//# sourceMappingURL=terminal.error.js.map

package/lib/browser/terminal.ext.host.proxy.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalProcessExtHostProxy = void 0;
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+class TerminalProcessExtHostProxy extends ide_core_common_1.Disposable {
+    get onProcessReady() {
+        return this._onProcessReady.event;
+    }
+    get onProcessOverrideDimensions() {
+        return this._onProcessOverrideDimensions.event;
+    }
+    constructor(terminalId, _cols, _rows, controller) {
+        super();
+        this.terminalId = terminalId;
+        this._cols = _cols;
+        this._rows = _rows;
+        this.controller = controller;
+        this._onProcessData = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onProcessData = this._onProcessData.event;
+        this._onProcessExit = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onProcessExit = this._onProcessExit.event;
+        this._onProcessReady = this.registerDispose(new ide_core_common_1.Emitter());
+        this._onProcessTitleChanged = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onProcessTitleChanged = this._onProcessTitleChanged.event;
+        this._onProcessOverrideDimensions = this.registerDispose(new ide_core_common_1.Emitter());
+        this._onStart = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onStart = this._onStart.event;
+        this._onInput = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onInput = this._onInput.event;
+        this._onResize = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onResize = this._onResize.event;
+        this._onShutdown = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onShutdown = this._onShutdown.event;
+        this._onRequestInitialCwd = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onRequestInitialCwd = this._onRequestInitialCwd.event;
+        this._onRequestCwd = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onRequestCwd = this._onRequestCwd.event;
+        this._onRequestLatency = this.registerDispose(new ide_core_common_1.Emitter());
+        this.onRequestLatency = this._onRequestLatency.event;
+        this._pendingInitialCwdRequests = [];
+        this._pendingCwdRequests = [];
+        this._pendingLatencyRequests = [];
+    }
+    emitData(data) {
+        this._onProcessData.fire(data);
+    }
+    emitTitle(title) {
+        this._onProcessTitleChanged.fire(title);
+    }
+    emitReady(pid, cwd) {
+        this._onProcessReady.fire({ pid, cwd });
+    }
+    emitExit(exitCode) {
+        this._onProcessExit.fire(exitCode);
+        this.dispose();
+    }
+    emitOverrideDimensions(dimensions) {
+        this._onProcessOverrideDimensions.fire(dimensions);
+    }
+    emitInitialCwd(initialCwd) {
+        while (this._pendingInitialCwdRequests.length > 0) {
+            this._pendingInitialCwdRequests.pop()(initialCwd);
+        }
+    }
+    emitCwd(cwd) {
+        while (this._pendingCwdRequests.length > 0) {
+            this._pendingCwdRequests.pop()(cwd);
+        }
+    }
+    emitLatency(latency) {
+        while (this._pendingLatencyRequests.length > 0) {
+            this._pendingLatencyRequests.pop()(latency);
+        }
+    }
+    async start() {
+        // 目前仅支持扩展 Terminal
+        return this.controller.requestStartExtensionTerminal(this, this._cols, this._rows);
+    }
+    shutdown(immediate) {
+        this._onShutdown.fire(immediate);
+    }
+    input(data) {
+        this._onInput.fire(data);
+    }
+    resize(cols, rows) {
+        this._onResize.fire({ cols, rows });
+    }
+    getInitialCwd() {
+        return new Promise((resolve) => {
+            this._onRequestInitialCwd.fire();
+            this._pendingInitialCwdRequests.push(resolve);
+        });
+    }
+    getCwd() {
+        return new Promise((resolve) => {
+            this._onRequestCwd.fire();
+            this._pendingCwdRequests.push(resolve);
+        });
+    }
+    getLatency() {
+        return new Promise((resolve) => {
+            this._onRequestLatency.fire();
+            this._pendingLatencyRequests.push(resolve);
+        });
+    }
+}
+exports.TerminalProcessExtHostProxy = TerminalProcessExtHostProxy;
+//# sourceMappingURL=terminal.ext.host.proxy.js.map

package/lib/browser/terminal.hover.manager.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalHoverManagerService = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+const TIPS_OFFSET_Y = 20;
+const TIPS_OFFSET_X = 5;
+let TerminalHoverManagerService = class TerminalHoverManagerService {
+    appendTerminalHoverOverlay() {
+        let overlayContainer = document.querySelector('#terminal-link-hover-overlay');
+        if (!overlayContainer) {
+            overlayContainer = document.createElement('div');
+            overlayContainer.id = 'terminal-link-hover-overlay';
+            document.body.appendChild(overlayContainer);
+        }
+        const overlay = document.createElement('div');
+        overlay.classList.add('terminal-hover-overlay');
+        overlayContainer.appendChild(overlay);
+        this.hoverOverlay = overlay;
+    }
+    appendTerminalHoverContainer() {
+        var _a;
+        this.hoverWidget = document.createElement('div');
+        this.hoverWidget.style.display = 'none';
+        this.hoverWidget.style.position = 'fixed';
+        this.hoverWidget.style.color = 'var(--editorWidget-foreground)';
+        this.hoverWidget.style.backgroundColor = 'var(--editorWidget-background)';
+        this.hoverWidget.style.borderColor = 'var(--editorWidget-border)';
+        this.hoverWidget.style.borderWidth = '0.5px';
+        this.hoverWidget.style.borderStyle = 'solid';
+        this.hoverWidget.style.padding = '5px';
+        this.hoverWidget.style.top = '-500px';
+        this.hoverWidget.style.left = '-500px';
+        this.hoverWidget.style.zIndex = '10';
+        this.hoverWidget.classList.add('hover-container');
+        if (!this.hoverOverlay) {
+            this.appendTerminalHoverOverlay();
+        }
+        (_a = this.hoverOverlay) === null || _a === void 0 ? void 0 : _a.appendChild(this.hoverWidget);
+    }
+    setHoverOverlay(overlay) {
+        this.hoverOverlay = overlay;
+    }
+    showHover(targetOptions, text, linkHandler) {
+        if (!this.hoverWidget) {
+            this.appendTerminalHoverContainer();
+        }
+        const viewportRange = targetOptions.viewportRange;
+        const cellDimensions = targetOptions.cellDimensions;
+        const boundingClientRect = targetOptions.boundingClientRect;
+        if (this.hoverWidget) {
+            this.hoverWidget.textContent = text;
+            this.hoverWidget.style.display = 'inline';
+        }
+        // wait for the hover widget to be rendered
+        requestAnimationFrame(() => {
+            if (this.hoverWidget) {
+                this.hoverWidget.style.top = `${(viewportRange.start.y - 1) * cellDimensions.height + boundingClientRect.y - TIPS_OFFSET_Y}px`;
+                let tooltipsLeft = viewportRange.start.x * cellDimensions.width + boundingClientRect.x + TIPS_OFFSET_X;
+                // if the tooltip is too close to the right edge of the terminal, move it to the left
+                if (tooltipsLeft + this.hoverWidget.clientWidth > boundingClientRect.x + boundingClientRect.width) {
+                    tooltipsLeft = boundingClientRect.x + boundingClientRect.width - this.hoverWidget.clientWidth - TIPS_OFFSET_X;
+                }
+                this.hoverWidget.style.left = `${tooltipsLeft}px`;
+            }
+        });
+        return ide_core_common_1.Disposable.create(() => this.dispose());
+    }
+    hideHover() {
+        if (this.hoverWidget) {
+            this.dispose();
+        }
+    }
+    dispose() {
+        var _a;
+        (_a = this.hoverWidget) === null || _a === void 0 ? void 0 : _a.remove();
+        this.hoverWidget = undefined;
+    }
+};
+exports.TerminalHoverManagerService = TerminalHoverManagerService;
+exports.TerminalHoverManagerService = TerminalHoverManagerService = tslib_1.__decorate([
+    (0, di_1.Injectable)()
+], TerminalHoverManagerService);
+//# sourceMappingURL=terminal.hover.manager.js.map

package/lib/browser/terminal.input.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalKeyBoardInputService = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+let TerminalKeyBoardInputService = class TerminalKeyBoardInputService {
+    constructor() {
+        this._isCommandOrCtrl = false;
+    }
+    get isCommandOrCtrl() {
+        return this._isCommandOrCtrl;
+    }
+    listen() {
+        const key = ide_core_common_1.isMacintosh ? 'Meta' : 'Control';
+        document.addEventListener('keydown', (e) => {
+            if (e.key === key) {
+                this._isCommandOrCtrl = true;
+            }
+        });
+        document.addEventListener('keyup', (e) => {
+            if (e.key === key) {
+                this._isCommandOrCtrl = false;
+            }
+        });
+    }
+};
+exports.TerminalKeyBoardInputService = TerminalKeyBoardInputService;
+exports.TerminalKeyBoardInputService = TerminalKeyBoardInputService = tslib_1.__decorate([
+    (0, di_1.Injectable)()
+], TerminalKeyBoardInputService);
+//# sourceMappingURL=terminal.input.js.map

package/lib/browser/terminal.internal.service.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalInternalService = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const common_1 = require("../common");
+let TerminalInternalService = class TerminalInternalService {
+    constructor() {
+        this._processExtHostProxies = new Map();
+    }
+    generateSessionId() {
+        return this.service.generateSessionId ? this.service.generateSessionId() : (0, common_1.generateSessionId)();
+    }
+    getOptions() {
+        return this.service.getOptions ? this.service.getOptions() : {};
+    }
+    check(sessionIds) {
+        return this.service.check ? this.service.check(sessionIds) : Promise.resolve(true);
+    }
+    _getExtHostProxy(longId) {
+        return this._processExtHostProxies.get(longId);
+    }
+    async sendText(sessionId, message) {
+        const proxy = this._getExtHostProxy(sessionId);
+        if (proxy) {
+            return proxy.emitData(message);
+        }
+        return this.service.sendText(sessionId, message);
+    }
+    async resize(sessionId, cols, rows) {
+        const proxy = this._getExtHostProxy(sessionId);
+        if (proxy) {
+            return proxy.resize(cols, rows);
+        }
+        return this.service.resize(sessionId, cols, rows);
+    }
+    disposeById(sessionId) {
+        const proxy = this._getExtHostProxy(sessionId);
+        if (proxy) {
+            this._processExtHostProxies.delete(sessionId);
+            return proxy.dispose();
+        }
+        return this.service.disposeById(sessionId);
+    }
+    async getProcessId(sessionId) {
+        const proxy = this._getExtHostProxy(sessionId);
+        if (proxy) {
+            return -1;
+        }
+        return this.service.getProcessId(sessionId);
+    }
+    onError(handler) {
+        return this.service.onError(handler);
+    }
+    onExit(handler) {
+        return this.service.onExit(handler);
+    }
+    onProcessChange(handler) {
+        return this.service.onProcessChange(handler);
+    }
+    async getOS() {
+        return await this.service.getOS();
+    }
+    async getProfiles(autoDetect) {
+        return await this.service.getProfiles(autoDetect);
+    }
+    async getDefaultSystemShell() {
+        return await this.service.getDefaultSystemShell();
+    }
+    async getCodePlatformKey() {
+        return await this.service.getCodePlatformKey();
+    }
+    async attachByLaunchConfig(sessionId, cols, rows, launchConfig, xterm) {
+        if (launchConfig.customPtyImplementation) {
+            const proxy = launchConfig.customPtyImplementation(sessionId, cols, rows);
+            proxy.start();
+            proxy.onProcessExit(() => {
+                this._processExtHostProxies.delete(sessionId);
+            });
+            this._processExtHostProxies.set(sessionId, proxy);
+            return {
+                name: launchConfig.name || 'ExtensionTerminal-' + sessionId,
+                readonly: false,
+                onData: proxy.onProcessData.bind(proxy),
+                sendData: proxy.input.bind(proxy),
+                onExit: proxy.onProcessExit.bind(proxy),
+            };
+        }
+        return await this.service.attachByLaunchConfig(sessionId, cols, rows, launchConfig, xterm);
+    }
+    async getCwd(sessionId) {
+        return await this.service.getCwd(sessionId);
+    }
+};
+exports.TerminalInternalService = TerminalInternalService;
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalInternalService.prototype, "service", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalController),
+    tslib_1.__metadata("design:type", Object)
+], TerminalInternalService.prototype, "controller", void 0);
+exports.TerminalInternalService = TerminalInternalService = tslib_1.__decorate([
+    (0, di_1.Injectable)()
+], TerminalInternalService);
+//# sourceMappingURL=terminal.internal.service.js.map