@codingame/monaco-vscode-log-service-override 4.4.0 → 4.5.0-improve-code-splitting.1

package/log.js

@@ -1,16 +1,18 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { ILoggerService, getLogLevel, ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { getLogLevel } from 'vscode/vscode/vs/platform/log/common/log';
 export { ConsoleLogger } from 'vscode/vscode/vs/platform/log/common/log';
+import { ILoggerService, ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { FileLoggerService } from './vscode/src/vs/platform/log/common/fileLog.js';
 import { LogService } from 'vscode/vscode/vs/platform/log/common/logService';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { windowLogId } from 'vscode/vscode/vs/workbench/services/log/common/logConstants';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IDefaultLogLevelsService, DefaultLogLevelsService } from 'vscode/vscode/vs/workbench/contrib/logs/common/defaultLogLevels';
+import { DefaultLogLevelsService } from './vscode/src/vs/workbench/contrib/logs/common/defaultLogLevels.js';
+import { IDefaultLogLevelsService } from 'vscode/vscode/vs/workbench/contrib/logs/common/defaultLogLevels.service';
 import getServiceOverride$1 from '@codingame/monaco-vscode-environment-service-override';
 import { logsPath } from 'vscode/workbench';
 import { checkServicesNotInitialized } from 'vscode/lifecycle';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-log-service-override",
-  "version": "4.4.0",
+  "version": "4.5.0-improve-code-splitting.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -17,8 +17,16 @@
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./vscode/*": {
+      "default": "./vscode/src/*.js"
+    }
+  },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.4.0",
-    "@codingame/monaco-vscode-environment-service-override": "4.4.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.5.0-improve-code-splitting.1",
+    "@codingame/monaco-vscode-environment-service-override": "4.5.0-improve-code-splitting.1"
   }
 }

package/vscode/src/vs/platform/log/common/fileLog.js

@@ -2,7 +2,8 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { ThrottledDelayer } from 'vscode/vscode/vs/base/common/async';
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { joinPath, dirname, basename } from 'vscode/vscode/vs/base/common/resources';
-import { ByteSize, IFileService, whenProviderRegistered } from 'vscode/vscode/vs/platform/files/common/files';
+import { ByteSize, whenProviderRegistered } from 'vscode/vscode/vs/platform/files/common/files';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { BufferLogger } from 'vscode/vscode/vs/platform/log/common/bufferLog';
 import { AbstractMessageLogger, LogLevel, AbstractLoggerService } from 'vscode/vscode/vs/platform/log/common/log';
 

package/vscode/src/vs/workbench/contrib/logs/common/defaultLogLevels.js

@@ -0,0 +1,158 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { getLogLevel, LogLevelToString, parseLogLevel } from 'vscode/vscode/vs/platform/log/common/log';
+import { ILogService, ILoggerService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { toFileOperationResult } from 'vscode/vscode/vs/platform/files/common/files';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { IJSONEditingService } from 'vscode/vscode/vs/workbench/services/configuration/common/jsonEditing.service';
+import { isUndefined, isString } from 'vscode/vscode/vs/base/common/types';
+import { EXTENSION_IDENTIFIER_WITH_LOG_REGEX } from '@codingame/monaco-vscode-environment-service-override/vscode/vs/platform/environment/common/environmentService';
+import { parse } from 'vscode/vscode/vs/base/common/json';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+let DefaultLogLevelsService = class DefaultLogLevelsService extends Disposable {
+    constructor(environmentService, fileService, jsonEditingService, logService, loggerService) {
+        super();
+        this.environmentService = environmentService;
+        this.fileService = fileService;
+        this.jsonEditingService = jsonEditingService;
+        this.logService = logService;
+        this.loggerService = loggerService;
+        this._onDidChangeDefaultLogLevels = this._register(( new Emitter()));
+        this.onDidChangeDefaultLogLevels = this._onDidChangeDefaultLogLevels.event;
+    }
+    async getDefaultLogLevels() {
+        const argvLogLevel = await this._parseLogLevelsFromArgv();
+        return {
+            default: argvLogLevel?.default ?? this._getDefaultLogLevelFromEnv(),
+            extensions: argvLogLevel?.extensions ?? this._getExtensionsDefaultLogLevelsFromEnv()
+        };
+    }
+    async getDefaultLogLevel(extensionId) {
+        const argvLogLevel = (await this._parseLogLevelsFromArgv()) ?? {};
+        if (extensionId) {
+            extensionId = extensionId.toLowerCase();
+            return this._getDefaultLogLevel(argvLogLevel, extensionId);
+        }
+        else {
+            return this._getDefaultLogLevel(argvLogLevel);
+        }
+    }
+    async setDefaultLogLevel(defaultLogLevel, extensionId) {
+        const argvLogLevel = (await this._parseLogLevelsFromArgv()) ?? {};
+        if (extensionId) {
+            extensionId = extensionId.toLowerCase();
+            const currentDefaultLogLevel = this._getDefaultLogLevel(argvLogLevel, extensionId);
+            argvLogLevel.extensions = argvLogLevel.extensions ?? [];
+            const extension = argvLogLevel.extensions.find(([extension]) => extension === extensionId);
+            if (extension) {
+                extension[1] = defaultLogLevel;
+            }
+            else {
+                argvLogLevel.extensions.push([extensionId, defaultLogLevel]);
+            }
+            await this._writeLogLevelsToArgv(argvLogLevel);
+            const extensionLoggers = [...this.loggerService.getRegisteredLoggers()].filter(logger => logger.extensionId && logger.extensionId.toLowerCase() === extensionId);
+            for (const { resource } of extensionLoggers) {
+                if (this.loggerService.getLogLevel(resource) === currentDefaultLogLevel) {
+                    this.loggerService.setLogLevel(resource, defaultLogLevel);
+                }
+            }
+        }
+        else {
+            const currentLogLevel = this._getDefaultLogLevel(argvLogLevel);
+            argvLogLevel.default = defaultLogLevel;
+            await this._writeLogLevelsToArgv(argvLogLevel);
+            if (this.loggerService.getLogLevel() === currentLogLevel) {
+                this.loggerService.setLogLevel(defaultLogLevel);
+            }
+        }
+        this._onDidChangeDefaultLogLevels.fire();
+    }
+    _getDefaultLogLevel(argvLogLevels, extension) {
+        if (extension) {
+            const extensionLogLevel = argvLogLevels.extensions?.find(([extensionId]) => extensionId === extension);
+            if (extensionLogLevel) {
+                return extensionLogLevel[1];
+            }
+        }
+        return argvLogLevels.default ?? getLogLevel(this.environmentService);
+    }
+    async _writeLogLevelsToArgv(logLevels) {
+        const logLevelsValue = [];
+        if (!isUndefined(logLevels.default)) {
+            logLevelsValue.push(LogLevelToString(logLevels.default));
+        }
+        for (const [extension, logLevel] of logLevels.extensions ?? []) {
+            logLevelsValue.push(`${extension}=${LogLevelToString(logLevel)}`);
+        }
+        await this.jsonEditingService.write(this.environmentService.argvResource, [{ path: ['log-level'], value: logLevelsValue.length ? logLevelsValue : undefined }], true);
+    }
+    async _parseLogLevelsFromArgv() {
+        const result = { extensions: [] };
+        const logLevels = await this._readLogLevelsFromArgv();
+        for (const extensionLogLevel of logLevels) {
+            const matches = EXTENSION_IDENTIFIER_WITH_LOG_REGEX.exec(extensionLogLevel);
+            if (matches && matches[1] && matches[2]) {
+                const logLevel = parseLogLevel(matches[2]);
+                if (!isUndefined(logLevel)) {
+                    result.extensions?.push([matches[1].toLowerCase(), logLevel]);
+                }
+            }
+            else {
+                const logLevel = parseLogLevel(extensionLogLevel);
+                if (!isUndefined(logLevel)) {
+                    result.default = logLevel;
+                }
+            }
+        }
+        return !isUndefined(result.default) || result.extensions?.length ? result : undefined;
+    }
+    async migrateLogLevels() {
+        const logLevels = await this._readLogLevelsFromArgv();
+        const regex = /^([^.]+\..+):(.+)$/;
+        if (( logLevels.some(extensionLogLevel => regex.test(extensionLogLevel)))) {
+            const argvLogLevel = await this._parseLogLevelsFromArgv();
+            if (argvLogLevel) {
+                await this._writeLogLevelsToArgv(argvLogLevel);
+            }
+        }
+    }
+    async _readLogLevelsFromArgv() {
+        try {
+            const content = await this.fileService.readFile(this.environmentService.argvResource);
+            const argv = parse(( content.value.toString()));
+            return isString(argv['log-level']) ? [argv['log-level']] : Array.isArray(argv['log-level']) ? argv['log-level'] : [];
+        }
+        catch (error) {
+            if (toFileOperationResult(error) !== 1 ) {
+                this.logService.error(error);
+            }
+        }
+        return [];
+    }
+    _getDefaultLogLevelFromEnv() {
+        return getLogLevel(this.environmentService);
+    }
+    _getExtensionsDefaultLogLevelsFromEnv() {
+        const result = [];
+        for (const [extension, logLevelValue] of this.environmentService.extensionLogLevel ?? []) {
+            const logLevel = parseLogLevel(logLevelValue);
+            if (!isUndefined(logLevel)) {
+                result.push([extension, logLevel]);
+            }
+        }
+        return result;
+    }
+};
+DefaultLogLevelsService = ( __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IJSONEditingService)),
+    ( __param(3, ILogService)),
+    ( __param(4, ILoggerService))
+], DefaultLogLevelsService));
+
+export { DefaultLogLevelsService };

package/vscode/src/vs/workbench/contrib/logs/common/logs.contribution.js

@@ -3,21 +3,25 @@ import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { SetLogLevelAction } from 'vscode/vscode/vs/workbench/contrib/logs/common/logsActions';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { IFileService, whenProviderRegistered } from 'vscode/vscode/vs/platform/files/common/files';
-import { Extensions as Extensions$1, IOutputService } from 'vscode/vscode/vs/workbench/services/output/common/output';
+import { SetLogLevelAction } from './logsActions.js';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { whenProviderRegistered } from 'vscode/vscode/vs/platform/files/common/files';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { Extensions } from 'vscode/vscode/vs/workbench/services/output/common/output';
+import { IOutputService } from 'vscode/vscode/vs/workbench/services/output/common/output.service';
 import { Disposable, DisposableMap, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ILogService, ILoggerService, CONTEXT_LOG_LEVEL, LogLevelToString, isLogLevel } from 'vscode/vscode/vs/platform/log/common/log';
+import { CONTEXT_LOG_LEVEL, LogLevelToString, isLogLevel } from 'vscode/vscode/vs/platform/log/common/log';
+import { ILogService, ILoggerService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { showWindowLogActionId, windowLogId } from 'vscode/vscode/vs/workbench/services/log/common/logConstants';
 import { createCancelablePromise, timeout } from 'vscode/vscode/vs/base/common/async';
 import { isCancellationError, getErrorMessage, CancellationError } from 'vscode/vscode/vs/base/common/errors';
-import { IDefaultLogLevelsService } from 'vscode/vscode/vs/workbench/contrib/logs/common/defaultLogLevels';
-import { IContextKeyService, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IDefaultLogLevelsService } from 'vscode/vscode/vs/workbench/contrib/logs/common/defaultLogLevels.service';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { CounterSet } from 'vscode/vscode/vs/base/common/map';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 
 registerAction2(class extends Action2 {
@@ -58,7 +62,7 @@ let LogOutputChannels = class LogOutputChannels extends Disposable {
         this.fileService = fileService;
         this.uriIdentityService = uriIdentityService;
         this.contextKeys = ( new CounterSet());
-        this.outputChannelRegistry = ( Registry.as(Extensions$1.OutputChannels));
+        this.outputChannelRegistry = ( Registry.as(Extensions.OutputChannels));
         this.loggerDisposables = this._register(( new DisposableMap()));
         const contextKey = CONTEXT_LOG_LEVEL.bindTo(contextKeyService);
         contextKey.set(LogLevelToString(loggerService.getLogLevel()));
@@ -222,5 +226,5 @@ let LogLevelMigration = class LogLevelMigration {
 LogLevelMigration = ( __decorate([
     ( __param(0, IDefaultLogLevelsService))
 ], LogLevelMigration));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LogOutputChannels, 3 );
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LogLevelMigration, 4 );
+( Registry.as(Extensions$1.Workbench)).registerWorkbenchContribution(LogOutputChannels, 3 );
+( Registry.as(Extensions$1.Workbench)).registerWorkbenchContribution(LogLevelMigration, 4 );

package/vscode/src/vs/workbench/contrib/logs/common/logsActions.js

@@ -0,0 +1,237 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { isLogLevel, LogLevel, LogLevelToLocalizedString } from 'vscode/vscode/vs/platform/log/common/log';
+import { ILoggerService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { basename, dirname, isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { IOutputService } from 'vscode/vscode/vs/workbench/services/output/common/output.service';
+import { telemetryLogId, extensionTelemetryLogChannelId } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { IDefaultLogLevelsService } from 'vscode/vscode/vs/workbench/contrib/logs/common/defaultLogLevels.service';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+
+var SetLogLevelAction_1;
+let SetLogLevelAction = class SetLogLevelAction extends Action {
+    static { SetLogLevelAction_1 = this; }
+    static { this.ID = 'workbench.action.setLogLevel'; }
+    static { this.TITLE = ( localize2WithPath(
+        'vs/workbench/contrib/logs/common/logsActions',
+        'setLogLevel',
+        "Set Log Level..."
+    )); }
+    constructor(id, label, quickInputService, loggerService, outputService, defaultLogLevelsService) {
+        super(id, label);
+        this.quickInputService = quickInputService;
+        this.loggerService = loggerService;
+        this.outputService = outputService;
+        this.defaultLogLevelsService = defaultLogLevelsService;
+    }
+    async run() {
+        const logLevelOrChannel = await this.selectLogLevelOrChannel();
+        if (logLevelOrChannel !== null) {
+            if (isLogLevel(logLevelOrChannel)) {
+                this.loggerService.setLogLevel(logLevelOrChannel);
+            }
+            else {
+                await this.setLogLevelForChannel(logLevelOrChannel);
+            }
+        }
+    }
+    async selectLogLevelOrChannel() {
+        const defaultLogLevels = await this.defaultLogLevelsService.getDefaultLogLevels();
+        const extensionLogs = [], logs = [];
+        const logLevel = this.loggerService.getLogLevel();
+        for (const channel of this.outputService.getChannelDescriptors()) {
+            if (!SetLogLevelAction_1.isLevelSettable(channel) || !channel.file) {
+                continue;
+            }
+            const channelLogLevel = this.loggerService.getLogLevel(channel.file) ?? logLevel;
+            const item = { id: channel.id, resource: channel.file, label: channel.label, description: channelLogLevel !== logLevel ? this.getLabel(channelLogLevel) : undefined, extensionId: channel.extensionId };
+            if (channel.extensionId) {
+                extensionLogs.push(item);
+            }
+            else {
+                logs.push(item);
+            }
+        }
+        const entries = [];
+        entries.push({ type: 'separator', label: ( localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'all', "All")) });
+        entries.push(...this.getLogLevelEntries(defaultLogLevels.default, this.loggerService.getLogLevel(), true));
+        if (extensionLogs.length) {
+            entries.push({ type: 'separator', label: ( localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'extensionLogs',
+                "Extension Logs"
+            )) });
+            entries.push(...extensionLogs.sort((a, b) => a.label.localeCompare(b.label)));
+        }
+        entries.push({ type: 'separator', label: ( localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'loggers', "Logs")) });
+        entries.push(...logs.sort((a, b) => a.label.localeCompare(b.label)));
+        return ( new Promise((resolve, reject) => {
+            const disposables = ( new DisposableStore());
+            const quickPick = this.quickInputService.createQuickPick();
+            quickPick.placeholder = ( localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'selectlog',
+                "Set Log Level"
+            ));
+            quickPick.items = entries;
+            let selectedItem;
+            disposables.add(quickPick.onDidTriggerItemButton(e => {
+                quickPick.hide();
+                this.defaultLogLevelsService.setDefaultLogLevel(e.item.level);
+            }));
+            disposables.add(quickPick.onDidAccept(e => {
+                selectedItem = quickPick.selectedItems[0];
+                quickPick.hide();
+            }));
+            disposables.add(quickPick.onDidHide(() => {
+                const result = selectedItem ? selectedItem.level ?? selectedItem : null;
+                disposables.dispose();
+                resolve(result);
+            }));
+            quickPick.show();
+        }));
+    }
+    static isLevelSettable(channel) {
+        return channel.log && channel.file !== undefined && channel.id !== telemetryLogId && channel.id !== extensionTelemetryLogChannelId;
+    }
+    async setLogLevelForChannel(logChannel) {
+        const defaultLogLevels = await this.defaultLogLevelsService.getDefaultLogLevels();
+        const defaultLogLevel = defaultLogLevels.extensions.find(e => e[0] === logChannel.extensionId?.toLowerCase())?.[1] ?? defaultLogLevels.default;
+        const currentLogLevel = this.loggerService.getLogLevel(logChannel.resource) ?? defaultLogLevel;
+        const entries = this.getLogLevelEntries(defaultLogLevel, currentLogLevel, !!logChannel.extensionId);
+        return ( new Promise((resolve, reject) => {
+            const disposables = ( new DisposableStore());
+            const quickPick = this.quickInputService.createQuickPick();
+            quickPick.placeholder = logChannel ? ( localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'selectLogLevelFor',
+                " {0}: Select log level",
+                logChannel?.label
+            )) : ( localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'selectLogLevel',
+                "Select log level"
+            ));
+            quickPick.items = entries;
+            quickPick.activeItems = entries.filter((entry) => entry.level === this.loggerService.getLogLevel());
+            let selectedItem;
+            disposables.add(quickPick.onDidTriggerItemButton(e => {
+                quickPick.hide();
+                this.defaultLogLevelsService.setDefaultLogLevel(e.item.level, logChannel.extensionId);
+            }));
+            disposables.add(quickPick.onDidAccept(e => {
+                selectedItem = quickPick.selectedItems[0];
+                quickPick.hide();
+            }));
+            disposables.add(quickPick.onDidHide(() => {
+                if (selectedItem) {
+                    this.loggerService.setLogLevel(logChannel.resource, selectedItem.level);
+                }
+                disposables.dispose();
+                resolve();
+            }));
+            quickPick.show();
+        }));
+    }
+    getLogLevelEntries(defaultLogLevel, currentLogLevel, canSetDefaultLogLevel) {
+        const button = canSetDefaultLogLevel ? { iconClass: ThemeIcon.asClassName(Codicon.checkAll), tooltip: ( localizeWithPath(
+            'vs/workbench/contrib/logs/common/logsActions',
+            'resetLogLevel',
+            "Set as Default Log Level"
+        )) } : undefined;
+        return [
+            { label: this.getLabel(LogLevel.Trace, currentLogLevel), level: LogLevel.Trace, description: this.getDescription(LogLevel.Trace, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Trace ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Debug, currentLogLevel), level: LogLevel.Debug, description: this.getDescription(LogLevel.Debug, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Debug ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Info, currentLogLevel), level: LogLevel.Info, description: this.getDescription(LogLevel.Info, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Info ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Warning, currentLogLevel), level: LogLevel.Warning, description: this.getDescription(LogLevel.Warning, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Warning ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Error, currentLogLevel), level: LogLevel.Error, description: this.getDescription(LogLevel.Error, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Error ? [button] : undefined },
+            { label: this.getLabel(LogLevel.Off, currentLogLevel), level: LogLevel.Off, description: this.getDescription(LogLevel.Off, defaultLogLevel), buttons: button && defaultLogLevel !== LogLevel.Off ? [button] : undefined },
+        ];
+    }
+    getLabel(level, current) {
+        const label = LogLevelToLocalizedString(level).value;
+        return level === current ? `$(check) ${label}` : label;
+    }
+    getDescription(level, defaultLogLevel) {
+        return defaultLogLevel === level ? ( localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'default', "Default")) : undefined;
+    }
+};
+SetLogLevelAction = SetLogLevelAction_1 = ( __decorate([
+    ( __param(2, IQuickInputService)),
+    ( __param(3, ILoggerService)),
+    ( __param(4, IOutputService)),
+    ( __param(5, IDefaultLogLevelsService))
+], SetLogLevelAction));
+(class OpenWindowSessionLogFileAction extends Action {
+    static { this.ID = 'workbench.action.openSessionLogFile'; }
+    static { this.TITLE = ( localize2WithPath(
+        'vs/workbench/contrib/logs/common/logsActions',
+        'openSessionLogFile',
+        "Open Window Log File (Session)..."
+    )); }
+    constructor(id, label, environmentService, fileService, quickInputService, editorService) {
+        super(id, label);
+        this.environmentService = environmentService;
+        this.fileService = fileService;
+        this.quickInputService = quickInputService;
+        this.editorService = editorService;
+    }
+    async run() {
+        const sessionResult = await this.quickInputService.pick(this.getSessions().then(sessions => ( sessions.map((s, index) => ({
+            id: ( s.toString()),
+            label: basename(s),
+            description: index === 0 ? ( localizeWithPath('vs/workbench/contrib/logs/common/logsActions', 'current', "Current")) : undefined
+        })))), {
+            canPickMany: false,
+            placeHolder: ( localizeWithPath(
+                'vs/workbench/contrib/logs/common/logsActions',
+                'sessions placeholder',
+                "Select Session"
+            ))
+        });
+        if (sessionResult) {
+            const logFileResult = await this.quickInputService.pick(this.getLogFiles(( URI.parse(sessionResult.id))).then(logFiles => ( logFiles.map(s => ({
+                id: ( s.toString()),
+                label: basename(s)
+            })))), {
+                canPickMany: false,
+                placeHolder: ( localizeWithPath(
+                    'vs/workbench/contrib/logs/common/logsActions',
+                    'log placeholder',
+                    "Select Log file"
+                ))
+            });
+            if (logFileResult) {
+                return this.editorService.openEditor({ resource: ( URI.parse(logFileResult.id)), options: { pinned: true } }).then(() => undefined);
+            }
+        }
+    }
+    async getSessions() {
+        const logsPath = this.environmentService.logsHome.with({ scheme: this.environmentService.logFile.scheme });
+        const result = [logsPath];
+        const stat = await this.fileService.resolve(dirname(logsPath));
+        if (stat.children) {
+            result.push(...( stat.children
+                .filter(stat => !isEqual(stat.resource, logsPath) && stat.isDirectory && /^\d{8}T\d{6}$/.test(stat.name))
+                .sort()
+                .reverse()
+                .map(d => d.resource)));
+        }
+        return result;
+    }
+    async getLogFiles(session) {
+        const stat = await this.fileService.resolve(session);
+        if (stat.children) {
+            return ( stat.children.filter(stat => !stat.isDirectory).map(stat => stat.resource));
+        }
+        return [];
+    }
+});
+
+export { SetLogLevelAction };