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

package/lib/browser/terminal.network.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalNetworkService = 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 TerminalNetworkService = class TerminalNetworkService extends ide_core_common_1.Disposable {
+    constructor() {
+        super();
+        this._onConnect = new ide_core_common_1.Emitter();
+        this.onConnect = this._onConnect.event;
+        this._onDisconnect = new ide_core_common_1.Emitter();
+        this.onDisconnect = this._onDisconnect.event;
+        this._status = common_1.TerminalNetworkStatus.DISCONNECTED;
+        this._resetRetryTimers = new Map();
+        this._reconnectInfo = new Map();
+        this.controller.onDidCloseTerminal((e) => {
+            this._resetRetryTimers.delete(e.id);
+            this._reconnectInfo.delete(e.id);
+        });
+        this.onDispose(() => {
+            if (this._timer) {
+                clearTimeout(this._timer);
+            }
+        });
+    }
+    get status() {
+        return this._status;
+    }
+    setStatus(status) {
+        this._status = status;
+        if (status === common_1.TerminalNetworkStatus.CONNECTED) {
+            this._onConnect.fire();
+            this.scheduleReconnection();
+        }
+        else {
+            this._onDisconnect.fire();
+        }
+    }
+    bindErrors() {
+        this.service.onError(this.handleError.bind(this));
+    }
+    handleError(error) {
+        if (error.shouldReconnect == null) {
+            error.shouldReconnect = true;
+        }
+        const sessionId = error.id;
+        const reconnectInfo = this.getReconnectInfo(sessionId);
+        if (reconnectInfo.times) {
+            reconnectInfo.nextRetry = Date.now() + 2000;
+        }
+        this._reconnectInfo.set(sessionId, reconnectInfo);
+        this.scheduleReconnection();
+    }
+    reconnect() {
+        if (this._status === common_1.TerminalNetworkStatus.DISCONNECTED) {
+            return;
+        }
+        const now = Date.now();
+        let delay = Number.POSITIVE_INFINITY;
+        for (const sessionId of this.errorService.errors.keys()) {
+            if (!this.shouldReconnect(sessionId)) {
+                continue;
+            }
+            const { nextRetry } = this.getReconnectInfo(sessionId);
+            if (nextRetry > now) {
+                delay = Math.min(delay, nextRetry - now);
+            }
+            else {
+                this.reconnectClient(sessionId);
+            }
+        }
+        // 存在需要延迟重试的终端
+        if (delay < Number.POSITIVE_INFINITY) {
+            this.scheduleReconnection(delay);
+        }
+    }
+    async reconnectClient(sessionId) {
+        this.countRetry(sessionId);
+        const reconnected = this.errorService.fix(sessionId);
+        reconnected.then(() => {
+            this.resetRetryLater(sessionId);
+        });
+        return reconnected;
+    }
+    getReconnectInfo(sessionId) {
+        const reconnectInfo = this._reconnectInfo.get(sessionId);
+        return (reconnectInfo || {
+            times: 0,
+            nextRetry: 0,
+        });
+    }
+    countRetry(sessionId) {
+        const timer = this._resetRetryTimers.get(sessionId);
+        if (timer) {
+            clearTimeout(timer);
+            this._resetRetryTimers.delete(sessionId);
+        }
+        const reconnectInfo = this.getReconnectInfo(sessionId);
+        reconnectInfo.times += 1;
+        this._reconnectInfo.set(sessionId, reconnectInfo);
+    }
+    /**
+     * 连接成功后重置重连计数
+     * 这里延迟的作用是避免网络不稳定时频繁断连导致计数重置
+     */
+    resetRetryLater(sessionId) {
+        const timer = window.setTimeout(() => {
+            this._reconnectInfo.delete(sessionId);
+            this._resetRetryTimers.delete(sessionId);
+        }, 8000);
+        this._resetRetryTimers.set(sessionId, timer);
+    }
+    scheduleReconnection(delay = 200) {
+        if (this._timer) {
+            return;
+        }
+        this._timer = window.setTimeout(() => {
+            this._timer = undefined;
+            this.reconnect();
+        }, delay);
+    }
+    shouldReconnect(sessionId) {
+        const error = this.errorService.errors.get(sessionId);
+        if (!(error === null || error === void 0 ? void 0 : error.shouldReconnect)) {
+            return false;
+        }
+        const retried = this.getReconnectInfo(sessionId).times;
+        return retried < 3;
+    }
+};
+exports.TerminalNetworkService = TerminalNetworkService;
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalErrorService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalNetworkService.prototype, "errorService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalInternalService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalNetworkService.prototype, "service", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalController),
+    tslib_1.__metadata("design:type", Object)
+], TerminalNetworkService.prototype, "controller", void 0);
+exports.TerminalNetworkService = TerminalNetworkService = tslib_1.__decorate([
+    (0, di_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], TerminalNetworkService);
+//# sourceMappingURL=terminal.network.js.map

package/lib/browser/terminal.preference.js

@@ -0,0 +1,136 @@
+"use strict";
+var TerminalPreference_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalPreference = void 0;
+const tslib_1 = require("tslib");
+const pickBy_1 = tslib_1.__importDefault(require("lodash/pickBy"));
+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 preference_1 = require("../common/preference");
+let TerminalPreference = TerminalPreference_1 = class TerminalPreference {
+    _prefToOption(pref) {
+        if (pref.startsWith('terminal.integrated.')) {
+            return pref.replace('terminal.integrated.', '');
+        }
+        else {
+            return pref.replace('terminal.', '');
+        }
+    }
+    _optionToPref(option) {
+        return `terminal.${option}`;
+    }
+    _valid(option, value) {
+        return this.toValidOption(option, value) || TerminalPreference_1.defaultOptions[option];
+    }
+    constructor() {
+        this._onChange = new ide_core_common_1.Emitter();
+        this.onChange = this._onChange.event;
+        this.service.onPreferenceChanged(({ preferenceName, newValue, oldValue }) => {
+            const name = this._prefToOption(preferenceName);
+            if (newValue === oldValue) {
+                return;
+            }
+            if (preference_1.SupportedOptionsName[name]) {
+                this._onChange.fire({
+                    name,
+                    value: this._valid(name, newValue),
+                });
+            }
+        });
+    }
+    getCodeCompatibleOption() {
+        const options = {
+            copyOnSelection: this.service.get("terminal.integrated.copyOnSelection" /* CodeTerminalSettingId.CopyOnSelection */),
+            cursorBlink: this.service.get("terminal.integrated.cursorBlinking" /* CodeTerminalSettingId.CursorBlinking */),
+            fontSize: this.service.get("terminal.integrated.fontSize" /* CodeTerminalSettingId.FontSize */),
+            scrollback: this.service.get("terminal.integrated.scrollback" /* CodeTerminalSettingId.Scrollback */),
+            fontFamily: this.service.get("terminal.integrated.fontFamily" /* CodeTerminalSettingId.FontFamily */) || this.service.get('editor.fontFamily'),
+            fontWeight: this.service.get("terminal.integrated.fontWeight" /* CodeTerminalSettingId.FontWeight */),
+            fontWeightBold: this.service.get("terminal.integrated.fontWeightBold" /* CodeTerminalSettingId.FontWeightBold */),
+            cursorStyle: this.service.get("terminal.integrated.cursorStyle" /* CodeTerminalSettingId.CursorStyle */) === 'line'
+                ? 'bar'
+                : this.service.get("terminal.integrated.cursorStyle" /* CodeTerminalSettingId.CursorStyle */),
+            cursorWidth: this.service.get("terminal.integrated.cursorWidth" /* CodeTerminalSettingId.CursorWidth */),
+            lineHeight: this.service.get("terminal.integrated.lineHeight" /* CodeTerminalSettingId.LineHeight */),
+            letterSpacing: this.service.get("terminal.integrated.letterSpacing" /* CodeTerminalSettingId.LetterSpacing */),
+            fastScrollSensitivity: this.service.get("terminal.integrated.fastScrollSensitivity" /* CodeTerminalSettingId.FastScrollSensitivity */),
+        };
+        return (0, pickBy_1.default)(options, (val) => val !== undefined);
+    }
+    /**
+     * @param option 终端的 option 选项名
+     */
+    get(option) {
+        const val = this.service.get(this._optionToPref(option), TerminalPreference_1.defaultOptions[option]);
+        return this._valid(option, val);
+    }
+    /**
+     * @param option 终端的 option 选项名
+     */
+    getOrUndefined(option) {
+        const val = this.service.get(this._optionToPref(option));
+        return val;
+    }
+    toValidOption(option, value) {
+        switch (option) {
+            case preference_1.SupportedOptionsName.fontSize:
+                return value > 5 ? value : 5;
+            case preference_1.SupportedOptionsName.cursorStyle:
+                return value === 'line' ? 'bar' : value;
+            default:
+                return value;
+        }
+    }
+    /**
+     * 遍历所有支持项，用户没有设置该项则返回空
+     */
+    getOptions() {
+        const options = {};
+        Object.entries(preference_1.SupportedOptionsName).forEach(([name]) => {
+            if (!name) {
+                return;
+            }
+            const val = this.getOrUndefined(name);
+            if (val) {
+                options[name] = val;
+            }
+        });
+        return options;
+    }
+    toJSON() {
+        return {
+            ...TerminalPreference_1.defaultOptions,
+            ...this.getCodeCompatibleOption(),
+            ...this.getOptions(),
+        };
+    }
+};
+exports.TerminalPreference = TerminalPreference;
+TerminalPreference.defaultOptions = {
+    allowTransparency: false,
+    macOptionIsMeta: false,
+    cursorBlink: false,
+    scrollback: 2500,
+    tabStopWidth: 8,
+    fontSize: 12,
+    customGlyphs: true,
+    drawBoldTextInBrightColors: true,
+    fastScrollModifier: 'alt',
+    fastScrollSensitivity: 5,
+    scrollSensitivity: 1,
+    overviewRulerWidth: 10,
+    copyOnSelection: false,
+    fontWeightBold: 'bold',
+    fontFamily: "Menlo, Monaco, 'Courier New', monospace",
+    cursorStyle: 'block',
+};
+tslib_1.__decorate([
+    (0, di_1.Autowired)(ide_core_browser_1.PreferenceService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalPreference.prototype, "service", void 0);
+exports.TerminalPreference = TerminalPreference = TerminalPreference_1 = tslib_1.__decorate([
+    (0, di_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], TerminalPreference);
+//# sourceMappingURL=terminal.preference.js.map

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

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * TerminalProfileService 是管理 terminal profiles 的基础类
+ * 但我们要在这个 Service 上做一些封装，比如解析 terminal.type 等来制造一个假的 Profile
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalProfileInternalService = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const ide_core_browser_1 = require("@opensumi/ide-core-browser");
+const common_1 = require("../common");
+const generatedProfileName = 'Generated Profile';
+let TerminalProfileInternalService = class TerminalProfileInternalService {
+    async resolveTerminalTypeProfile() {
+        var _a, _b;
+        const shellType = this.preferenceService.get("terminal.type" /* TerminalSettingsId.Type */);
+        if (!shellType || shellType === 'default') {
+            // 继续走我们的 resolveDefaultProfile
+            return;
+        }
+        let shellPath = shellType;
+        const args = [];
+        const platformKey = await this.terminalService.getCodePlatformKey();
+        const terminalOs = await this.terminalService.getOS();
+        if (terminalOs === ide_core_browser_1.OperatingSystem.Windows) {
+            shellPath = (_a = (await this.serviceClientRPC.$resolveWindowsShellPath(shellType))) !== null && _a !== void 0 ? _a : shellPath;
+        }
+        else {
+            shellPath = (_b = (await this.serviceClientRPC.$resolveUnixShellPath(shellType))) !== null && _b !== void 0 ? _b : shellPath;
+        }
+        const platformSpecificArgs = this.preferenceService.get(`${"terminal.integrated.shellArgs." /* CodeTerminalSettingPrefix.ShellArgs */}${platformKey}`, []);
+        args.push(...platformSpecificArgs);
+        return {
+            profileName: 'terminal.type',
+            path: shellPath,
+            args,
+            icon: undefined,
+            isDefault: false,
+        };
+    }
+    async resolveDefaultProfile(options) {
+        // 兼容之前的 terminal.type
+        const _defaultPorfile = await this.resolveTerminalTypeProfile();
+        if (_defaultPorfile) {
+            return _defaultPorfile;
+        }
+        await this.profileService.profilesReady;
+        let profile = await this.resolveRealDefaultProfile();
+        if (!profile) {
+            profile = await this._resolvedFallbackDefaultProfile(options);
+        }
+        return profile;
+    }
+    async resolveRealDefaultProfile() {
+        await this.profileService.profilesReady;
+        const defaultProfileName = this.profileService.getDefaultProfileName();
+        if (!defaultProfileName) {
+            return undefined;
+        }
+        return this.profileService.availableProfiles.find((v) => v.profileName === defaultProfileName);
+    }
+    async _resolvedFallbackDefaultProfile(options) {
+        var _a;
+        const executable = await this.terminalService.getDefaultSystemShell();
+        // Finally fallback to a generated profile
+        let args;
+        const os = (_a = options === null || options === void 0 ? void 0 : options.os) !== null && _a !== void 0 ? _a : (await this.terminalService.getOS());
+        if (os === ide_core_browser_1.OperatingSystem.Macintosh && ide_core_browser_1.path.parse(executable).name.match(/(zsh|bash)/)) {
+            // macOS should launch a login shell by default
+            args = ['--login'];
+        }
+        else {
+            // Resolve undefined to []
+            args = [];
+        }
+        return {
+            profileName: generatedProfileName,
+            path: executable,
+            args,
+            isDefault: false,
+        };
+    }
+};
+exports.TerminalProfileInternalService = TerminalProfileInternalService;
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalProfileService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalProfileInternalService.prototype, "profileService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalProfileInternalService.prototype, "terminalService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(ide_core_browser_1.PreferenceService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalProfileInternalService.prototype, "preferenceService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalServicePath),
+    tslib_1.__metadata("design:type", Object)
+], TerminalProfileInternalService.prototype, "serviceClientRPC", void 0);
+exports.TerminalProfileInternalService = TerminalProfileInternalService = tslib_1.__decorate([
+    (0, di_1.Injectable)()
+], TerminalProfileInternalService);
+//# sourceMappingURL=terminal.profile.internal.js.map

package/lib/browser/terminal.profile.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalProfileService = void 0;
+const tslib_1 = require("tslib");
+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("../common");
+const { equals } = ide_core_common_1.arrays;
+let TerminalProfileService = class TerminalProfileService extends ide_core_common_1.WithEventBus {
+    /**
+     * 当用户创建了一个 Profile 时发出的事件
+     */
+    get onTerminalProfileResolved() {
+        return this.onTerminalProfileResolvedEmitter.event;
+    }
+    get onDidChangeDefaultShell() {
+        return this.onDidChangeDefaultShellEmitter.event;
+    }
+    get profilesReady() {
+        return this._profilesReadyBarrier.wait().then(() => { });
+    }
+    get onDidChangeAvailableProfiles() {
+        return this._onDidChangeAvailableProfiles.event;
+    }
+    constructor() {
+        super();
+        this.onTerminalProfileResolvedEmitter = new ide_core_common_1.Emitter();
+        this.onDidChangeDefaultShellEmitter = new ide_core_common_1.Emitter();
+        this._onDidChangeAvailableProfiles = new ide_core_common_1.Emitter();
+        this._profileProviders = new Map();
+        this._contributedProfiles = [];
+        // #region 外部插件贡献的 Terminal Profiles
+        this._rawContributedProfileMap = new Map();
+        // Wait up to 5 seconds for profiles to be ready so it's assured that we know the actual
+        // default terminal before launching the first terminal. This isn't expected to ever take
+        // this long.
+        this._profilesReadyBarrier = new ide_core_common_1.AutoOpenBarrier(5000);
+        this.refreshAvailableProfiles();
+        this.setupPreferenceListener();
+    }
+    get availableProfiles() {
+        return this._availableProfiles || [];
+    }
+    get contributedProfiles() {
+        return this._contributedProfiles || [];
+    }
+    setupPreferenceListener() {
+        this.preferenceService.onPreferenceChanged((event) => {
+            if (event.preferenceName === "terminal.type" /* TerminalSettingsId.Type */) {
+                /**
+                 * @todo 因 profile 相关能力未完全实现，因此这里先手动派发一个 change shell 的事件
+                 * 实现完成后，这里应该调用 this.refreshAvailableProfiles();
+                 */
+                this.onDidChangeDefaultShellEmitter.fire(event.newValue);
+            }
+        });
+    }
+    getDefaultProfileName() {
+        return this.preferenceService.get(`${"terminal.integrated.defaultProfile." /* CodeTerminalSettingPrefix.DefaultProfile */}${this.terminalService.getCodePlatformKey()}`);
+    }
+    refreshAvailableProfiles() {
+        this._refreshAvailableProfilesNow();
+    }
+    getContributedProfileProvider(extensionIdentifier, id) {
+        const extMap = this._profileProviders.get(extensionIdentifier);
+        return extMap === null || extMap === void 0 ? void 0 : extMap.get(id);
+    }
+    async createContributedTerminalProfile(extensionIdentifier, id, options) {
+        await this.onTerminalProfileResolvedEmitter.fireAndAwait(id);
+        const profileProvider = this.getContributedProfileProvider(extensionIdentifier, id);
+        if (!profileProvider) {
+            this.logger.error(`No terminal profile provider registered for id "${id}"`);
+            return;
+        }
+        try {
+            await profileProvider.createContributedTerminalProfile(options);
+        }
+        catch (e) {
+            this.logger.error('create contributed terminal profile error:', e.message);
+        }
+    }
+    registerTerminalProfileProvider(extensionIdentifier, id, profileProvider) {
+        let extMap = this._profileProviders.get(extensionIdentifier);
+        if (!extMap) {
+            extMap = new Map();
+            this._profileProviders.set(extensionIdentifier, extMap);
+        }
+        extMap.set(id, profileProvider);
+        return ide_core_common_1.Disposable.create(() => this._profileProviders.delete(id));
+    }
+    async _detectProfiles(autoDetect = true) {
+        return await this.terminalService.getProfiles(autoDetect);
+    }
+    async _updateContributedProfiles() {
+        const platformKey = await this.terminalService.getCodePlatformKey();
+        const excludedContributedProfiles = [];
+        const configProfiles = this.preferenceService.get("terminal.integrated.profiles." /* CodeTerminalSettingPrefix.Profiles */ + platformKey, {});
+        for (const [profileName, value] of Object.entries(configProfiles)) {
+            if (value === null) {
+                excludedContributedProfiles.push(profileName);
+            }
+        }
+        const filteredContributedProfiles = Array.from(this.rawContributedProfiles.filter((p) => !excludedContributedProfiles.includes(p.title)));
+        const contributedProfilesChanged = !equals(filteredContributedProfiles, this._contributedProfiles, contributedProfilesEqual);
+        this._contributedProfiles = filteredContributedProfiles;
+        return contributedProfilesChanged;
+    }
+    async _refreshAvailableProfilesNow() {
+        const profiles = await this._detectProfiles(true);
+        const profilesChanged = !equals(profiles, this._availableProfiles, profilesEqual);
+        const contributedProfilesChanged = await this._updateContributedProfiles();
+        if (profilesChanged || contributedProfilesChanged) {
+            this._availableProfiles = profiles;
+            this._profilesReadyBarrier.open();
+            this._onDidChangeAvailableProfiles.fire(this._availableProfiles);
+        }
+    }
+    async getContributedDefaultProfile(shellLaunchConfig) {
+        // prevents recursion with the MainThreadTerminalService call to create terminal
+        // and defers to the provided launch config when an executable is provided
+        if (shellLaunchConfig && !shellLaunchConfig.extHostTerminalId && !('executable' in shellLaunchConfig)) {
+            const key = await this.terminalService.getCodePlatformKey();
+            const defaultProfileName = this.preferenceService.get(`${"terminal.integrated.defaultProfile." /* CodeTerminalSettingPrefix.DefaultProfile */}${key}`);
+            const contributedDefaultProfile = this.contributedProfiles.find((p) => p.title === defaultProfileName);
+            return contributedDefaultProfile;
+        }
+        return undefined;
+    }
+    async saveContributedProfile(args) {
+        const platformKey = await this.terminalService.getCodePlatformKey();
+        const profilesConfig = await this.preferenceService.get(`${"terminal.integrated.profiles." /* CodeTerminalSettingPrefix.Profiles */}${platformKey}`);
+        if (typeof profilesConfig === 'object') {
+            const newProfile = {
+                extensionIdentifier: args.extensionIdentifier,
+                icon: args.options.icon,
+                id: args.id,
+                title: args.title,
+                color: args.options.color,
+            };
+            profilesConfig[args.title] = newProfile;
+        }
+        await this.preferenceService.set(`${"terminal.integrated.profiles." /* CodeTerminalSettingPrefix.Profiles */}${platformKey}`, profilesConfig, ide_core_common_1.PreferenceScope.User);
+        return;
+    }
+    get rawContributedProfiles() {
+        return Array.from(this._rawContributedProfileMap.values());
+    }
+    addContributedProfile(extensionId, contributions) {
+        var _a;
+        const profiles = ((_a = contributions === null || contributions === void 0 ? void 0 : contributions.profiles) === null || _a === void 0 ? void 0 : _a.filter((p) => hasValidTerminalIcon(p)).map((e) => ({ ...e, extensionIdentifier: extensionId }))) || [];
+        for (const profile of profiles) {
+            this._rawContributedProfileMap.set(profile.id, profile);
+        }
+        this.refreshAvailableProfiles();
+    }
+    removeContributedProfile(extensionId) {
+        const profiles = this.rawContributedProfiles;
+        for (const profile of profiles) {
+            if (profile.extensionIdentifier === extensionId) {
+                this._rawContributedProfileMap.delete(profile.id);
+            }
+        }
+    }
+};
+exports.TerminalProfileService = TerminalProfileService;
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalProfileService.prototype, "terminalService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(ide_core_browser_1.PreferenceService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalProfileService.prototype, "preferenceService", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(ide_core_common_1.ILogger),
+    tslib_1.__metadata("design:type", Object)
+], TerminalProfileService.prototype, "logger", void 0);
+tslib_1.__decorate([
+    (0, ide_core_common_1.throttle)(2000),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
+], TerminalProfileService.prototype, "refreshAvailableProfiles", null);
+exports.TerminalProfileService = TerminalProfileService = tslib_1.__decorate([
+    (0, di_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [])
+], TerminalProfileService);
+function profilesEqual(one, other) {
+    return (one.profileName === other.profileName &&
+        (0, common_1.terminalProfileArgsMatch)(one.args, other.args) &&
+        one.color === other.color &&
+        one.isAutoDetected === other.isAutoDetected &&
+        one.isDefault === other.isDefault &&
+        one.overrideName === other.overrideName &&
+        one.path === other.path);
+}
+function contributedProfilesEqual(one, other) {
+    return (one.extensionIdentifier === other.extensionIdentifier &&
+        one.color === other.color &&
+        one.icon === other.icon &&
+        one.id === other.id &&
+        one.title === other.title);
+}
+function hasValidTerminalIcon(profile) {
+    return (!profile.icon ||
+        typeof profile.icon === 'string' ||
+        ide_core_common_1.URI.isUri(profile.icon) ||
+        ('light' in profile.icon && 'dark' in profile.icon && ide_core_common_1.URI.isUri(profile.icon.light) && ide_core_common_1.URI.isUri(profile.icon.dark)));
+}
+//# sourceMappingURL=terminal.profile.js.map

package/lib/browser/terminal.render.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalRenderProvider = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const tab_item_1 = require("./component/tab.item");
+let TerminalRenderProvider = class TerminalRenderProvider {
+    /**
+     * @override terminal tab item renderer
+     */
+    get infoItemRender() {
+        return tab_item_1.renderInfoItem;
+    }
+    /**
+     * @override terminal add item renderer
+     */
+    get addItemRender() {
+        return tab_item_1.renderAddItem;
+    }
+};
+exports.TerminalRenderProvider = TerminalRenderProvider;
+exports.TerminalRenderProvider = TerminalRenderProvider = tslib_1.__decorate([
+    (0, di_1.Injectable)()
+], TerminalRenderProvider);
+//# sourceMappingURL=terminal.render.js.map

package/lib/browser/terminal.restore.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalRestore = void 0;
+const tslib_1 = require("tslib");
+const di_1 = require("@opensumi/di");
+const ide_core_browser_1 = require("@opensumi/ide-core-browser");
+const common_1 = require("../common");
+const DEFAULT_TERMINAL_STORE_KEY = 'OPENSUMI_TERMINAL_RESTORE';
+let TerminalRestore = class TerminalRestore extends ide_core_browser_1.Disposable {
+    get storageKey() {
+        // 集成方可以根据自己的场景来通过 override 自定义 storageKey 做到终端恢复场景的准确性
+        return DEFAULT_TERMINAL_STORE_KEY;
+    }
+    save() {
+        const json = this.controller.toJSON();
+        const key = this.storageKey;
+        this.scopedBrowserStorageService.setData(key, json);
+    }
+    restore() {
+        const key = this.storageKey;
+        const history = this.scopedBrowserStorageService.getData(key);
+        if (history) {
+            try {
+                return this.controller.recovery(history);
+            }
+            catch (_e) {
+                /** nothing */
+            }
+        }
+        return Promise.resolve();
+    }
+};
+exports.TerminalRestore = TerminalRestore;
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalController),
+    tslib_1.__metadata("design:type", Object)
+], TerminalRestore.prototype, "controller", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(common_1.ITerminalInternalService),
+    tslib_1.__metadata("design:type", Object)
+], TerminalRestore.prototype, "service", void 0);
+tslib_1.__decorate([
+    (0, di_1.Autowired)(ide_core_browser_1.ScopedBrowserStorageService),
+    tslib_1.__metadata("design:type", ide_core_browser_1.ScopedBrowserStorageService)
+], TerminalRestore.prototype, "scopedBrowserStorageService", void 0);
+exports.TerminalRestore = TerminalRestore = tslib_1.__decorate([
+    (0, di_1.Injectable)()
+], TerminalRestore);
+//# sourceMappingURL=terminal.restore.js.map