@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/localHistory/browser/localHistoryFileSystemProvider.js

@@ -0,0 +1,87 @@
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { FileType, hasReadWriteCapability } from '../../../../platform/files/common/files.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import { VSBuffer } from '../../../../base/common/buffer.js';
+class LocalHistoryFileSystemProvider {
+    static { this.SCHEMA = 'vscode-local-history'; }
+    static toLocalHistoryFileSystem(resource) {
+        const serializedLocalHistoryResource = {
+            location: ( resource.location.toString(true)),
+            associatedResource: ( resource.associatedResource.toString(true))
+        };
+        return resource.associatedResource.with({
+            scheme: LocalHistoryFileSystemProvider.SCHEMA,
+            query: JSON.stringify(serializedLocalHistoryResource)
+        });
+    }
+    static fromLocalHistoryFileSystem(resource) {
+        const serializedLocalHistoryResource = JSON.parse(resource.query);
+        return {
+            location: ( URI.parse(serializedLocalHistoryResource.location)),
+            associatedResource: ( URI.parse(serializedLocalHistoryResource.associatedResource))
+        };
+    }
+    static { this.EMPTY_RESOURCE = ( URI.from({ scheme: LocalHistoryFileSystemProvider.SCHEMA, path: '/empty' })); }
+    static { this.EMPTY = {
+        location: LocalHistoryFileSystemProvider.EMPTY_RESOURCE,
+        associatedResource: LocalHistoryFileSystemProvider.EMPTY_RESOURCE
+    }; }
+    get capabilities() {
+        return 2  | 2048 ;
+    }
+    constructor(fileService) {
+        this.fileService = fileService;
+        this.mapSchemeToProvider = ( new Map());
+        this.onDidChangeCapabilities = Event.None;
+        this.onDidChangeFile = Event.None;
+    }
+    async withProvider(resource) {
+        const scheme = resource.scheme;
+        let providerPromise = this.mapSchemeToProvider.get(scheme);
+        if (!providerPromise) {
+            const provider = this.fileService.getProvider(scheme);
+            if (provider) {
+                providerPromise = Promise.resolve(provider);
+            }
+            else {
+                providerPromise = ( new Promise(resolve => {
+                    const disposable = this.fileService.onDidChangeFileSystemProviderRegistrations(e => {
+                        if (e.added && e.provider && e.scheme === scheme) {
+                            disposable.dispose();
+                            resolve(e.provider);
+                        }
+                    });
+                }));
+            }
+            this.mapSchemeToProvider.set(scheme, providerPromise);
+        }
+        return providerPromise;
+    }
+    async stat(resource) {
+        const location = LocalHistoryFileSystemProvider.fromLocalHistoryFileSystem(resource).location;
+        if (isEqual(LocalHistoryFileSystemProvider.EMPTY_RESOURCE, location)) {
+            return { type: FileType.File, ctime: 0, mtime: 0, size: 0 };
+        }
+        return (await this.withProvider(location)).stat(location);
+    }
+    async readFile(resource) {
+        const location = LocalHistoryFileSystemProvider.fromLocalHistoryFileSystem(resource).location;
+        if (isEqual(LocalHistoryFileSystemProvider.EMPTY_RESOURCE, location)) {
+            return VSBuffer.fromString('').buffer;
+        }
+        const provider = await this.withProvider(location);
+        if (hasReadWriteCapability(provider)) {
+            return provider.readFile(location);
+        }
+        throw new Error('Unsupported');
+    }
+    async writeFile(resource, content, opts) { }
+    async mkdir(resource) { }
+    async readdir(resource) { return []; }
+    async rename(from, to, opts) { }
+    async delete(resource, opts) { }
+    watch(resource, opts) { return Disposable.None; }
+}
+export { LocalHistoryFileSystemProvider };

package/vscode/src/vs/workbench/contrib/localHistory/browser/localHistoryTimeline.js

@@ -0,0 +1,136 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { ITimelineService } from '../../timeline/common/timeline.js';
+import { IWorkingCopyHistoryService } from '../../../services/workingCopy/common/workingCopyHistory.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IPathService } from '../../../services/path/common/pathService.js';
+import { API_OPEN_DIFF_EDITOR_COMMAND_ID } from '../../../browser/parts/editor/editorCommands.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { LocalHistoryFileSystemProvider } from './localHistoryFileSystemProvider.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { SaveSourceRegistry } from '../../../common/editor.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { COMPARE_WITH_FILE_LABEL, toDiffEditorArguments } from './localHistoryCommands.js';
+import { MarkdownString } from '../../../../base/common/htmlContent.js';
+import { getLocalHistoryDateFormatter, LOCAL_HISTORY_ICON_ENTRY, LOCAL_HISTORY_MENU_CONTEXT_VALUE } from './localHistory.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { getVirtualWorkspaceAuthority } from '../../../../platform/workspace/common/virtualWorkspace.js';
+var LocalHistoryTimeline_1;
+let LocalHistoryTimeline = class LocalHistoryTimeline extends Disposable {
+    static { LocalHistoryTimeline_1 = this; }
+    static { this.ID = 'workbench.contrib.localHistoryTimeline'; }
+    static { this.LOCAL_HISTORY_ENABLED_SETTINGS_KEY = 'workbench.localHistory.enabled'; }
+    constructor(timelineService, workingCopyHistoryService, pathService, fileService, environmentService, configurationService, contextService) {
+        super();
+        this.timelineService = timelineService;
+        this.workingCopyHistoryService = workingCopyHistoryService;
+        this.pathService = pathService;
+        this.fileService = fileService;
+        this.environmentService = environmentService;
+        this.configurationService = configurationService;
+        this.contextService = contextService;
+        this.id = 'timeline.localHistory';
+        this.label = ( localizeWithPath(
+            'vs/workbench/contrib/localHistory/browser/localHistoryTimeline',
+            'localHistory',
+            "Local History"
+        ));
+        this.scheme = '*';
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.timelineProviderDisposable = this._register(( new MutableDisposable()));
+        this.registerComponents();
+        this.registerListeners();
+    }
+    registerComponents() {
+        this.updateTimelineRegistration();
+        this._register(this.fileService.registerProvider(LocalHistoryFileSystemProvider.SCHEMA, ( new LocalHistoryFileSystemProvider(this.fileService))));
+    }
+    updateTimelineRegistration() {
+        if (this.configurationService.getValue(LocalHistoryTimeline_1.LOCAL_HISTORY_ENABLED_SETTINGS_KEY)) {
+            this.timelineProviderDisposable.value = this.timelineService.registerTimelineProvider(this);
+        }
+        else {
+            this.timelineProviderDisposable.clear();
+        }
+    }
+    registerListeners() {
+        this._register(this.workingCopyHistoryService.onDidAddEntry(e => this.onDidChangeWorkingCopyHistoryEntry(e.entry)));
+        this._register(this.workingCopyHistoryService.onDidChangeEntry(e => this.onDidChangeWorkingCopyHistoryEntry(e.entry)));
+        this._register(this.workingCopyHistoryService.onDidReplaceEntry(e => this.onDidChangeWorkingCopyHistoryEntry(e.entry)));
+        this._register(this.workingCopyHistoryService.onDidRemoveEntry(e => this.onDidChangeWorkingCopyHistoryEntry(e.entry)));
+        this._register(this.workingCopyHistoryService.onDidRemoveEntries(() => this.onDidChangeWorkingCopyHistoryEntry(undefined )));
+        this._register(this.workingCopyHistoryService.onDidMoveEntries(() => this.onDidChangeWorkingCopyHistoryEntry(undefined )));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(LocalHistoryTimeline_1.LOCAL_HISTORY_ENABLED_SETTINGS_KEY)) {
+                this.updateTimelineRegistration();
+            }
+        }));
+    }
+    onDidChangeWorkingCopyHistoryEntry(entry) {
+        this._onDidChange.fire({
+            id: this.id,
+            uri: entry?.workingCopy.resource,
+            reset: true
+        });
+    }
+    async provideTimeline(uri, options, token) {
+        const items = [];
+        let resource = undefined;
+        if (uri.scheme === LocalHistoryFileSystemProvider.SCHEMA) {
+            resource = LocalHistoryFileSystemProvider.fromLocalHistoryFileSystem(uri).associatedResource;
+        }
+        else if (uri.scheme === this.pathService.defaultUriScheme || uri.scheme === Schemas.vscodeUserData) {
+            resource = uri;
+        }
+        else if (this.fileService.hasProvider(uri)) {
+            resource = ( URI.from({
+                scheme: this.pathService.defaultUriScheme,
+                authority: this.environmentService.remoteAuthority ?? getVirtualWorkspaceAuthority(this.contextService.getWorkspace()),
+                path: uri.path
+            }));
+        }
+        if (resource) {
+            const entries = await this.workingCopyHistoryService.getEntries(resource, token);
+            for (const entry of entries) {
+                items.push(this.toTimelineItem(entry));
+            }
+        }
+        return {
+            source: this.id,
+            items
+        };
+    }
+    toTimelineItem(entry) {
+        return {
+            handle: entry.id,
+            label: SaveSourceRegistry.getSourceLabel(entry.source),
+            tooltip: ( new MarkdownString(
+                `$(history) ${getLocalHistoryDateFormatter().format(entry.timestamp)}\n\n${SaveSourceRegistry.getSourceLabel(entry.source)}`,
+                { supportThemeIcons: true }
+            )),
+            source: this.id,
+            timestamp: entry.timestamp,
+            themeIcon: LOCAL_HISTORY_ICON_ENTRY,
+            contextValue: LOCAL_HISTORY_MENU_CONTEXT_VALUE,
+            command: {
+                id: API_OPEN_DIFF_EDITOR_COMMAND_ID,
+                title: COMPARE_WITH_FILE_LABEL.value,
+                arguments: toDiffEditorArguments(entry, entry.workingCopy.resource)
+            }
+        };
+    }
+};
+LocalHistoryTimeline = LocalHistoryTimeline_1 = ( __decorate([
+    ( __param(0, ITimelineService)),
+    ( __param(1, IWorkingCopyHistoryService)),
+    ( __param(2, IPathService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IWorkbenchEnvironmentService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IWorkspaceContextService))
+], LocalHistoryTimeline));
+export { LocalHistoryTimeline };

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

@@ -0,0 +1,225 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
+import { registerAction2, Action2 } from '../../../../platform/actions/common/actions.js';
+import { SetLogLevelAction } from './logsActions.js';
+import { Extensions } from '../../../common/contributions.js';
+import { whenProviderRegistered, IFileService } from '../../../../platform/files/common/files.js';
+import { Extensions as Extensions$1, IOutputService } from '../../../services/output/common/output.js';
+import { Disposable, DisposableMap, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { CONTEXT_LOG_LEVEL, LogLevelToString, isLogLevel, ILogService, ILoggerService } from '../../../../platform/log/common/log.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event } from '../../../../base/common/event.js';
+import { showWindowLogActionId, windowLogId } from '../../../services/log/common/logConstants.js';
+import { createCancelablePromise, timeout } from '../../../../base/common/async.js';
+import { isCancellationError, getErrorMessage, CancellationError } from '../../../../base/common/errors.js';
+import { IDefaultLogLevelsService } from './defaultLogLevels.js';
+import { ContextKeyExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { CounterSet } from '../../../../base/common/map.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { Schemas } from '../../../../base/common/network.js';
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: SetLogLevelAction.ID,
+            title: SetLogLevelAction.TITLE,
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(servicesAccessor) {
+        return servicesAccessor.get(IInstantiationService).createInstance(SetLogLevelAction, SetLogLevelAction.ID, SetLogLevelAction.TITLE.value).run();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.setDefaultLogLevel',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/logs/common/logs.contribution',
+                'setDefaultLogLevel',
+                "Set Default Log Level"
+            )),
+            category: Categories.Developer,
+        });
+    }
+    run(servicesAccessor, logLevel, extensionId) {
+        return servicesAccessor.get(IDefaultLogLevelsService).setDefaultLogLevel(logLevel, extensionId);
+    }
+});
+let LogOutputChannels = class LogOutputChannels extends Disposable {
+    constructor(logService, loggerService, contextKeyService, fileService, uriIdentityService) {
+        super();
+        this.logService = logService;
+        this.loggerService = loggerService;
+        this.contextKeyService = contextKeyService;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this.contextKeys = ( new CounterSet());
+        this.outputChannelRegistry = ( Registry.as(Extensions$1.OutputChannels));
+        this.loggerDisposables = this._register(( new DisposableMap()));
+        const contextKey = CONTEXT_LOG_LEVEL.bindTo(contextKeyService);
+        contextKey.set(LogLevelToString(loggerService.getLogLevel()));
+        loggerService.onDidChangeLogLevel(e => {
+            if (isLogLevel(e)) {
+                contextKey.set(LogLevelToString(loggerService.getLogLevel()));
+            }
+        });
+        this.onDidAddLoggers(loggerService.getRegisteredLoggers());
+        this._register(loggerService.onDidChangeLoggers(({ added, removed }) => {
+            this.onDidAddLoggers(added);
+            this.onDidRemoveLoggers(removed);
+        }));
+        this._register(loggerService.onDidChangeVisibility(([resource, visibility]) => {
+            const logger = loggerService.getRegisteredLogger(resource);
+            if (logger) {
+                if (visibility) {
+                    this.registerLogChannel(logger);
+                }
+                else {
+                    this.deregisterLogChannel(logger);
+                }
+            }
+        }));
+        this.registerShowWindowLogAction();
+        this._register(Event.filter(contextKeyService.onDidChangeContext, e => e.affectsSome(this.contextKeys))(() => this.onDidChangeContext()));
+    }
+    onDidAddLoggers(loggers) {
+        for (const logger of loggers) {
+            if (logger.when) {
+                const contextKeyExpr = ContextKeyExpr.deserialize(logger.when);
+                if (contextKeyExpr) {
+                    for (const key of ( contextKeyExpr.keys())) {
+                        this.contextKeys.add(key);
+                    }
+                    if (!this.contextKeyService.contextMatchesRules(contextKeyExpr)) {
+                        continue;
+                    }
+                }
+            }
+            if (logger.hidden) {
+                continue;
+            }
+            this.registerLogChannel(logger);
+        }
+    }
+    onDidChangeContext() {
+        for (const logger of this.loggerService.getRegisteredLoggers()) {
+            if (logger.when) {
+                if (this.contextKeyService.contextMatchesRules(ContextKeyExpr.deserialize(logger.when))) {
+                    this.registerLogChannel(logger);
+                }
+                else {
+                    this.deregisterLogChannel(logger);
+                }
+            }
+        }
+    }
+    onDidRemoveLoggers(loggers) {
+        for (const logger of loggers) {
+            if (logger.when) {
+                const contextKeyExpr = ContextKeyExpr.deserialize(logger.when);
+                if (contextKeyExpr) {
+                    for (const key of ( contextKeyExpr.keys())) {
+                        this.contextKeys.delete(key);
+                    }
+                }
+            }
+            this.deregisterLogChannel(logger);
+        }
+    }
+    registerLogChannel(logger) {
+        const channel = this.outputChannelRegistry.getChannel(logger.id);
+        if (channel && this.uriIdentityService.extUri.isEqual(channel.file, logger.resource)) {
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        const promise = createCancelablePromise(async (token) => {
+            await whenProviderRegistered(logger.resource, this.fileService);
+            try {
+                await this.whenFileExists(logger.resource, 1, token);
+                const existingChannel = this.outputChannelRegistry.getChannel(logger.id);
+                const remoteLogger = existingChannel?.file?.scheme === Schemas.vscodeRemote ? this.loggerService.getRegisteredLogger(existingChannel.file) : undefined;
+                if (remoteLogger) {
+                    this.deregisterLogChannel(remoteLogger);
+                }
+                const hasToAppendRemote = existingChannel && logger.resource.scheme === Schemas.vscodeRemote;
+                const id = hasToAppendRemote ? `${logger.id}.remote` : logger.id;
+                const label = hasToAppendRemote ? ( localizeWithPath(
+                    'vs/workbench/contrib/logs/common/logs.contribution',
+                    'remote name',
+                    "{0} (Remote)",
+                    logger.name ?? logger.id
+                )) : logger.name ?? logger.id;
+                this.outputChannelRegistry.registerChannel({ id, label, file: logger.resource, log: true, extensionId: logger.extensionId });
+                disposables.add(toDisposable(() => this.outputChannelRegistry.removeChannel(id)));
+                if (remoteLogger) {
+                    this.registerLogChannel(remoteLogger);
+                }
+            }
+            catch (error) {
+                if (!isCancellationError(error)) {
+                    this.logService.error('Error while registering log channel', ( logger.resource.toString()), getErrorMessage(error));
+                }
+            }
+        });
+        disposables.add(toDisposable(() => promise.cancel()));
+        this.loggerDisposables.set(( logger.resource.toString()), disposables);
+    }
+    deregisterLogChannel(logger) {
+        this.loggerDisposables.deleteAndDispose(( logger.resource.toString()));
+    }
+    async whenFileExists(file, trial, token) {
+        const exists = await this.fileService.exists(file);
+        if (exists) {
+            return;
+        }
+        if (token.isCancellationRequested) {
+            throw new CancellationError();
+        }
+        if (trial > 10) {
+            throw new Error(`Timed out while waiting for file to be created`);
+        }
+        this.logService.debug(`[Registering Log Channel] File does not exist. Waiting for 1s to retry.`, ( file.toString()));
+        await timeout(1000, token);
+        await this.whenFileExists(file, trial + 1, token);
+    }
+    registerShowWindowLogAction() {
+        this._register(registerAction2(class ShowWindowLogAction extends Action2 {
+            constructor() {
+                super({
+                    id: showWindowLogActionId,
+                    title: ( localize2WithPath(
+                        'vs/workbench/contrib/logs/common/logs.contribution',
+                        'show window log',
+                        "Show Window Log"
+                    )),
+                    category: Categories.Developer,
+                    f1: true
+                });
+            }
+            async run(servicesAccessor) {
+                const outputService = servicesAccessor.get(IOutputService);
+                outputService.showChannel(windowLogId);
+            }
+        }));
+    }
+};
+LogOutputChannels = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, ILoggerService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IUriIdentityService))
+], LogOutputChannels));
+let LogLevelMigration = class LogLevelMigration {
+    constructor(defaultLogLevelsService) {
+        defaultLogLevelsService.migrateLogLevels();
+    }
+};
+LogLevelMigration = ( __decorate([
+    ( __param(0, IDefaultLogLevelsService))
+], LogLevelMigration));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LogOutputChannels, 3 );
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LogLevelMigration, 4 );

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

@@ -4,10 +4,10 @@ import { Action } from '../../../../base/common/actions.js';
 import { isLogLevel, LogLevel, LogLevelToLocalizedString, ILoggerService } from '../../../../platform/log/common/log.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
 import { URI } from '../../../../base/common/uri.js';
-import '../../../../platform/files/common/files.js';
-import '../../../../platform/instantiation/common/instantiation.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
 import { basename, dirname, isEqual } from '../../../../base/common/resources.js';
-import '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { IOutputService } from '../../../services/output/common/output.js';
 import { telemetryLogId, extensionTelemetryLogChannelId } from '../../../../platform/telemetry/common/telemetryUtils.js';
 import { IDefaultLogLevelsService } from './defaultLogLevels.js';
@@ -168,7 +168,7 @@ SetLogLevelAction = SetLogLevelAction_1 = ( __decorate([
     ( __param(4, IOutputService)),
     ( __param(5, IDefaultLogLevelsService))
 ], SetLogLevelAction));
-(class OpenWindowSessionLogFileAction extends Action {
+let OpenWindowSessionLogFileAction = class OpenWindowSessionLogFileAction extends Action {
     static { this.ID = 'workbench.action.openSessionLogFile'; }
     static { this.TITLE = ( localize2WithPath(
         'vs/workbench/contrib/logs/common/logsActions',
@@ -232,5 +232,11 @@ SetLogLevelAction = SetLogLevelAction_1 = ( __decorate([
         }
         return [];
     }
-});
-export { SetLogLevelAction };
+};
+OpenWindowSessionLogFileAction = ( __decorate([
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IQuickInputService)),
+    ( __param(5, IEditorService))
+], OpenWindowSessionLogFileAction));
+export { OpenWindowSessionLogFileAction, SetLogLevelAction };