@codingame/monaco-vscode-timeline-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,89 @@
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { FileType, hasReadWriteCapability } from 'vscode/vscode/vs/platform/files/common/files';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+
+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,138 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ITimelineService } from 'vscode/vscode/vs/workbench/contrib/timeline/common/timeline';
+import { IWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { API_OPEN_DIFF_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { LocalHistoryFileSystemProvider } from './localHistoryFileSystemProvider.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { COMPARE_WITH_FILE_LABEL, toDiffEditorArguments } from './localHistoryCommands.js';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { getLocalHistoryDateFormatter, LOCAL_HISTORY_ICON_ENTRY, LOCAL_HISTORY_MENU_CONTEXT_VALUE } from './localHistory.js';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { getVirtualWorkspaceAuthority } from 'vscode/vscode/vs/platform/workspace/common/virtualWorkspace';
+
+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/timeline/browser/media/timelinePane.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-workbench .timeline-tree-view{position:relative}.monaco-workbench .timeline-tree-view .message.timeline-subtle{opacity:.5;padding:10px 22px 0;pointer-events:none;position:absolute;z-index:1}.timeline-tree-view .monaco-list .monaco-list-row .custom-view-tree-node-item .monaco-icon-label{flex:1;overflow:hidden;text-overflow:ellipsis}.timeline-tree-view .monaco-list .monaco-list-row .custom-view-tree-node-item .timeline-timestamp-container{margin-left:2px;margin-right:4px;opacity:.5;overflow:hidden;text-overflow:ellipsis}.timeline-tree-view .monaco-list .monaco-list-row .custom-view-tree-node-item .timeline-timestamp-container.timeline-timestamp--duplicate:before{border-right:1px solid;content:\" \";display:block;height:100%;opacity:.25;position:absolute;right:10px;width:1px}.timeline-tree-view .monaco-list .monaco-list-row.focused .custom-view-tree-node-item .timeline-timestamp-container.timeline-timestamp--duplicate:before,.timeline-tree-view .monaco-list .monaco-list-row.selected .custom-view-tree-node-item .timeline-timestamp-container.timeline-timestamp--duplicate:before,.timeline-tree-view .monaco-list .monaco-list-row:hover .custom-view-tree-node-item .timeline-timestamp-container.timeline-timestamp--duplicate:before{display:none}.timeline-tree-view .monaco-list .monaco-list-row .custom-view-tree-node-item .timeline-timestamp-container .timeline-timestamp{display:inline-block}.timeline-tree-view .monaco-list .monaco-list-row .custom-view-tree-node-item .timeline-timestamp-container.timeline-timestamp--duplicate .timeline-timestamp{visibility:hidden;width:10px}.timeline-tree-view .monaco-list .monaco-list-row.focused .custom-view-tree-node-item .timeline-timestamp-container.timeline-timestamp--duplicate .timeline-timestamp,.timeline-tree-view .monaco-list .monaco-list-row.selected .custom-view-tree-node-item .timeline-timestamp-container.timeline-timestamp--duplicate .timeline-timestamp,.timeline-tree-view .monaco-list .monaco-list-row:hover .custom-view-tree-node-item .timeline-timestamp-container.timeline-timestamp--duplicate .timeline-timestamp{visibility:visible!important;width:auto}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/timeline/browser/timeline.contribution.js

@@ -0,0 +1,120 @@
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/workbench/common/views';
+import { VIEW_CONTAINER } from 'vscode/vscode/vs/workbench/contrib/files/browser/explorerViewlet';
+import { TimelinePaneId, ITimelineService } from 'vscode/vscode/vs/workbench/contrib/timeline/common/timeline';
+import { TimelineHasProviderContext } from '../common/timelineService.js';
+import { TimelinePane } from './timelinePane.js';
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { MenuRegistry, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { ExplorerFolderContext } from 'vscode/vscode/vs/workbench/contrib/files/common/files';
+import { ResourceContextKey } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { registerIcon } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
+
+const timelineViewIcon = registerIcon('timeline-view-icon', Codicon.history, ( localizeWithPath(
+    'vs/workbench/contrib/timeline/browser/timeline.contribution',
+    'timelineViewIcon',
+    'View icon of the timeline view.'
+)));
+const timelineOpenIcon = registerIcon('timeline-open', Codicon.history, ( localizeWithPath(
+    'vs/workbench/contrib/timeline/browser/timeline.contribution',
+    'timelineOpenIcon',
+    'Icon for the open timeline action.'
+)));
+class TimelinePaneDescriptor {
+    constructor() {
+        this.id = TimelinePaneId;
+        this.name = TimelinePane.TITLE;
+        this.containerIcon = timelineViewIcon;
+        this.ctorDescriptor = ( new SyncDescriptor(TimelinePane));
+        this.order = 2;
+        this.weight = 30;
+        this.collapsed = true;
+        this.canToggleVisibility = true;
+        this.hideByDefault = false;
+        this.canMoveView = true;
+        this.when = TimelineHasProviderContext;
+        this.focusCommand = { id: 'timeline.focus' };
+    }
+}
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: 'timeline',
+    order: 1001,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/timeline/browser/timeline.contribution',
+        'timelineConfigurationTitle',
+        "Timeline"
+    )),
+    type: 'object',
+    properties: {
+        'timeline.pageSize': {
+            type: ['number', 'null'],
+            default: null,
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/timeline/browser/timeline.contribution',
+                'timeline.pageSize',
+                "The number of items to show in the Timeline view by default and when loading more items. Setting to `null` (the default) will automatically choose a page size based on the visible area of the Timeline view."
+            )),
+        },
+        'timeline.pageOnScroll': {
+            type: 'boolean',
+            default: false,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/timeline/browser/timeline.contribution',
+                'timeline.pageOnScroll',
+                "Experimental. Controls whether the Timeline view will load the next page of items when you scroll to the end of the list."
+            )),
+        },
+    }
+});
+( Registry.as(Extensions$1.ViewsRegistry)).registerViews([( new TimelinePaneDescriptor())], VIEW_CONTAINER);
+var OpenTimelineAction;
+( (function(OpenTimelineAction) {
+    OpenTimelineAction.ID = 'files.openTimeline';
+    OpenTimelineAction.LABEL = ( localizeWithPath(
+        'vs/workbench/contrib/timeline/browser/timeline.contribution',
+        'files.openTimeline',
+        "Open Timeline"
+    ));
+    function handler() {
+        return (accessor, arg) => {
+            const service = accessor.get(ITimelineService);
+            return service.setUri(arg);
+        };
+    }
+    OpenTimelineAction.handler = handler;
+})(OpenTimelineAction || (OpenTimelineAction = {})));
+CommandsRegistry.registerCommand(OpenTimelineAction.ID, OpenTimelineAction.handler());
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, ({
+    group: '4_timeline',
+    order: 1,
+    command: {
+        id: OpenTimelineAction.ID,
+        title: OpenTimelineAction.LABEL,
+        icon: timelineOpenIcon
+    },
+    when: ( ContextKeyExpr.and(( ExplorerFolderContext.toNegated()), ResourceContextKey.HasResource, TimelineHasProviderContext))
+}));
+const timelineFilter = registerIcon('timeline-filter', Codicon.filter, ( localizeWithPath(
+    'vs/workbench/contrib/timeline/browser/timeline.contribution',
+    'timelineFilter',
+    'Icon for the filter timeline action.'
+)));
+MenuRegistry.appendMenuItem(MenuId.TimelineTitle, {
+    submenu: MenuId.TimelineFilterSubMenu,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/timeline/browser/timeline.contribution',
+        'filterTimeline',
+        "Filter Timeline"
+    )),
+    group: 'navigation',
+    order: 100,
+    icon: timelineFilter
+});
+
+export { TimelinePaneDescriptor };