@codingame/monaco-vscode-api 3.2.3 → 4.1.0

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

@@ -0,0 +1,1161 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/timelinePane.css.js';
+import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
+import { clearNode, append, $, asCSSUrl } from '../../../../base/browser/dom.js';
+import { ActionRunner } from '../../../../base/common/actions.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { fromNow } from '../../../../base/common/date.js';
+import { debounce } from '../../../../base/common/decorators.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { createMatches } from '../../../../base/common/filters.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { DisposableStore, Disposable } from '../../../../base/common/lifecycle.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IconLabel } from '../../../../base/browser/ui/iconLabel/iconLabel.js';
+import { ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { WorkbenchObjectTree } from '../../../../platform/list/browser/listService.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { RawContextKey, IContextKeyService, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ITimelineService } from '../common/timeline.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { CommandsRegistry, ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
+import { createActionViewItem, createAndFillInContextMenuActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuId, registerAction2, MenuRegistry, Action2, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { ActionViewItem } from '../../../../base/browser/ui/actionbar/actionViewItems.js';
+import { ColorScheme } from '../../../../platform/theme/common/theme.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+import { API_OPEN_EDITOR_COMMAND_ID, API_OPEN_DIFF_EDITOR_COMMAND_ID } from '../../../browser/parts/editor/editorCommands.js';
+import { isString } from '../../../../base/common/types.js';
+import { renderMarkdownAsPlaintext } from '../../../../base/browser/markdownRenderer.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+const ItemHeight = 22;
+function isLoadMoreCommand(item) {
+    return item instanceof LoadMoreCommand;
+}
+function isTimelineItem(item) {
+    return !item?.handle.startsWith('vscode-command:') ?? false;
+}
+function updateRelativeTime(item, lastRelativeTime) {
+    item.relativeTime = isTimelineItem(item) ? fromNow(item.timestamp) : undefined;
+    item.relativeTimeFullWord = isTimelineItem(item) ? fromNow(item.timestamp, false, true) : undefined;
+    if (lastRelativeTime === undefined || item.relativeTime !== lastRelativeTime) {
+        lastRelativeTime = item.relativeTime;
+        item.hideRelativeTime = false;
+    }
+    else {
+        item.hideRelativeTime = true;
+    }
+    return lastRelativeTime;
+}
+class TimelineAggregate {
+    constructor(timeline) {
+        this._stale = false;
+        this._requiresReset = false;
+        this.source = timeline.source;
+        this.items = timeline.items;
+        this._cursor = timeline.paging?.cursor;
+        this.lastRenderedIndex = -1;
+    }
+    get cursor() {
+        return this._cursor;
+    }
+    get more() {
+        return this._cursor !== undefined;
+    }
+    get newest() {
+        return this.items[0];
+    }
+    get oldest() {
+        return this.items[this.items.length - 1];
+    }
+    add(timeline, options) {
+        let updated = false;
+        if (timeline.items.length !== 0 && this.items.length !== 0) {
+            updated = true;
+            const ids = ( new Set());
+            const timestamps = ( new Set());
+            for (const item of timeline.items) {
+                if (item.id === undefined) {
+                    timestamps.add(item.timestamp);
+                }
+                else {
+                    ids.add(item.id);
+                }
+            }
+            let i = this.items.length;
+            let item;
+            while (i--) {
+                item = this.items[i];
+                if ((item.id !== undefined && ( ids.has(item.id))) || ( timestamps.has(item.timestamp))) {
+                    this.items.splice(i, 1);
+                }
+            }
+            if ((timeline.items[timeline.items.length - 1]?.timestamp ?? 0) >= (this.newest?.timestamp ?? 0)) {
+                this.items.splice(0, 0, ...timeline.items);
+            }
+            else {
+                this.items.push(...timeline.items);
+            }
+        }
+        else if (timeline.items.length !== 0) {
+            updated = true;
+            this.items.push(...timeline.items);
+        }
+        if (options.cursor !== undefined || typeof options.limit !== 'object') {
+            this._cursor = timeline.paging?.cursor;
+        }
+        if (updated) {
+            this.items.sort((a, b) => (b.timestamp - a.timestamp) ||
+                (a.source === undefined
+                    ? b.source === undefined ? 0 : 1
+                    : b.source === undefined ? -1 : b.source.localeCompare(a.source, undefined, { numeric: true, sensitivity: 'base' })));
+        }
+        return updated;
+    }
+    get stale() {
+        return this._stale;
+    }
+    get requiresReset() {
+        return this._requiresReset;
+    }
+    invalidate(requiresReset) {
+        this._stale = true;
+        this._requiresReset = requiresReset;
+    }
+}
+class LoadMoreCommand {
+    constructor(loading) {
+        this.handle = 'vscode-command:loadMore';
+        this.timestamp = 0;
+        this.description = undefined;
+        this.tooltip = undefined;
+        this.contextValue = undefined;
+        this.id = undefined;
+        this.icon = undefined;
+        this.iconDark = undefined;
+        this.source = undefined;
+        this.relativeTime = undefined;
+        this.relativeTimeFullWord = undefined;
+        this.hideRelativeTime = undefined;
+        this._loading = false;
+        this._loading = loading;
+    }
+    get loading() {
+        return this._loading;
+    }
+    set loading(value) {
+        this._loading = value;
+    }
+    get ariaLabel() {
+        return this.label;
+    }
+    get label() {
+        return this.loading ? ( localizeWithPath(
+            'vs/workbench/contrib/timeline/browser/timelinePane',
+            'timeline.loadingMore',
+            "Loading..."
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/timeline/browser/timelinePane',
+            'timeline.loadMore',
+            "Load more"
+        ));
+    }
+    get themeIcon() {
+        return undefined;
+    }
+}
+const TimelineFollowActiveEditorContext = ( new RawContextKey('timelineFollowActiveEditor', true, true));
+const TimelineExcludeSources = ( new RawContextKey('timelineExcludeSources', '[]', true));
+let TimelinePane = class TimelinePane extends ViewPane {
+    static { this.TITLE = ( localize2WithPath(
+        'vs/workbench/contrib/timeline/browser/timelinePane',
+        'timeline',
+        "Timeline"
+    )); }
+    constructor(options, keybindingService, contextMenuService, contextKeyService, configurationService, storageService, viewDescriptorService, instantiationService, editorService, commandService, progressService, timelineService, openerService, themeService, telemetryService, labelService, uriIdentityService, extensionService) {
+        super({ ...options, titleMenuId: MenuId.TimelineTitle }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.storageService = storageService;
+        this.editorService = editorService;
+        this.commandService = commandService;
+        this.progressService = progressService;
+        this.timelineService = timelineService;
+        this.labelService = labelService;
+        this.uriIdentityService = uriIdentityService;
+        this.extensionService = extensionService;
+        this.pendingRequests = ( new Map());
+        this.timelinesBySource = ( new Map());
+        this._followActiveEditor = true;
+        this._isEmpty = true;
+        this._maxItemCount = 0;
+        this._visibleItemCount = 0;
+        this._pendingRefresh = false;
+        this.commands = this._register(this.instantiationService.createInstance(TimelinePaneCommands, this));
+        this.followActiveEditorContext = TimelineFollowActiveEditorContext.bindTo(this.contextKeyService);
+        this.timelineExcludeSourcesContext = TimelineExcludeSources.bindTo(this.contextKeyService);
+        const excludedSourcesString = storageService.get('timeline.excludeSources', 0 , '[]');
+        this.timelineExcludeSourcesContext.set(excludedSourcesString);
+        this.excludedSources = ( new Set(JSON.parse(excludedSourcesString)));
+        this._register(storageService.onDidChangeValue(0 , 'timeline.excludeSources', this._register(( new DisposableStore())))(this.onStorageServiceChanged, this));
+        this._register(configurationService.onDidChangeConfiguration(this.onConfigurationChanged, this));
+        this._register(timelineService.onDidChangeProviders(this.onProvidersChanged, this));
+        this._register(timelineService.onDidChangeTimeline(this.onTimelineChanged, this));
+        this._register(timelineService.onDidChangeUri(uri => this.setUri(uri), this));
+    }
+    get followActiveEditor() {
+        return this._followActiveEditor;
+    }
+    set followActiveEditor(value) {
+        if (this._followActiveEditor === value) {
+            return;
+        }
+        this._followActiveEditor = value;
+        this.followActiveEditorContext.set(value);
+        this.updateFilename(this._filename);
+        if (value) {
+            this.onActiveEditorChanged();
+        }
+    }
+    get pageOnScroll() {
+        if (this._pageOnScroll === undefined) {
+            this._pageOnScroll = this.configurationService.getValue('timeline.pageOnScroll') ?? false;
+        }
+        return this._pageOnScroll;
+    }
+    get pageSize() {
+        let pageSize = this.configurationService.getValue('timeline.pageSize');
+        if (pageSize === undefined || pageSize === null) {
+            pageSize = Math.max(20, Math.floor((this.tree?.renderHeight ?? 0 / ItemHeight) + (this.pageOnScroll ? 1 : -1)));
+        }
+        return pageSize;
+    }
+    reset() {
+        this.loadTimeline(true);
+    }
+    setUri(uri) {
+        this.setUriCore(uri, true);
+    }
+    setUriCore(uri, disableFollowing) {
+        if (disableFollowing) {
+            this.followActiveEditor = false;
+        }
+        this.uri = uri;
+        this.updateFilename(uri ? this.labelService.getUriBasenameLabel(uri) : undefined);
+        this.treeRenderer?.setUri(uri);
+        this.loadTimeline(true);
+    }
+    onStorageServiceChanged() {
+        const excludedSourcesString = this.storageService.get('timeline.excludeSources', 0 , '[]');
+        this.timelineExcludeSourcesContext.set(excludedSourcesString);
+        this.excludedSources = ( new Set(JSON.parse(excludedSourcesString)));
+        const missing = this.timelineService.getSources()
+            .filter(({ id }) => !( this.excludedSources.has(id)) && !( this.timelinesBySource.has(id)));
+        if (missing.length !== 0) {
+            this.loadTimeline(true, ( missing.map(({ id }) => id)));
+        }
+        else {
+            this.refresh();
+        }
+    }
+    onConfigurationChanged(e) {
+        if (e.affectsConfiguration('timeline.pageOnScroll')) {
+            this._pageOnScroll = undefined;
+        }
+    }
+    onActiveEditorChanged() {
+        if (!this.followActiveEditor || !this.isExpanded()) {
+            return;
+        }
+        const uri = EditorResourceAccessor.getOriginalUri(this.editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+        if ((this.uriIdentityService.extUri.isEqual(uri, this.uri) && uri !== undefined) ||
+            (uri?.fsPath === this.uri?.fsPath && (uri?.scheme === Schemas.file || uri?.scheme === 'git') && (this.uri?.scheme === Schemas.file || this.uri?.scheme === 'git'))) {
+            for (const source of this.timelineService.getSources()) {
+                if (( this.excludedSources.has(source.id))) {
+                    continue;
+                }
+                const timeline = this.timelinesBySource.get(source.id);
+                if (timeline !== undefined && !timeline.stale) {
+                    continue;
+                }
+                if (timeline !== undefined) {
+                    this.updateTimeline(timeline, timeline.requiresReset);
+                }
+                else {
+                    this.loadTimelineForSource(source.id, uri, true);
+                }
+            }
+            return;
+        }
+        this.setUriCore(uri, false);
+    }
+    onProvidersChanged(e) {
+        if (e.removed) {
+            for (const source of e.removed) {
+                this.timelinesBySource.delete(source);
+            }
+            this.refresh();
+        }
+        if (e.added) {
+            this.loadTimeline(true, e.added);
+        }
+    }
+    onTimelineChanged(e) {
+        if (e?.uri === undefined || this.uriIdentityService.extUri.isEqual(e.uri, this.uri)) {
+            const timeline = this.timelinesBySource.get(e.id);
+            if (timeline === undefined) {
+                return;
+            }
+            if (this.isBodyVisible()) {
+                this.updateTimeline(timeline, e.reset);
+            }
+            else {
+                timeline.invalidate(e.reset);
+            }
+        }
+    }
+    updateFilename(filename) {
+        this._filename = filename;
+        if (this.followActiveEditor || !filename) {
+            this.updateTitleDescription(filename);
+        }
+        else {
+            this.updateTitleDescription(`${filename} (pinned)`);
+        }
+    }
+    get message() {
+        return this._message;
+    }
+    set message(message) {
+        this._message = message;
+        this.updateMessage();
+    }
+    updateMessage() {
+        if (this._message !== undefined) {
+            this.showMessage(this._message);
+        }
+        else {
+            this.hideMessage();
+        }
+    }
+    showMessage(message) {
+        if (!this.$message) {
+            return;
+        }
+        this.$message.classList.remove('hide');
+        this.resetMessageElement();
+        this.$message.textContent = message;
+    }
+    hideMessage() {
+        this.resetMessageElement();
+        this.$message.classList.add('hide');
+    }
+    resetMessageElement() {
+        clearNode(this.$message);
+    }
+    get hasVisibleItems() {
+        return this._visibleItemCount > 0;
+    }
+    clear(cancelPending) {
+        this._visibleItemCount = 0;
+        this._maxItemCount = this.pageSize;
+        this.timelinesBySource.clear();
+        if (cancelPending) {
+            for (const { tokenSource } of ( this.pendingRequests.values())) {
+                tokenSource.dispose(true);
+            }
+            this.pendingRequests.clear();
+            if (!this.isBodyVisible() && this.tree) {
+                this.tree.setChildren(null, undefined);
+                this._isEmpty = true;
+            }
+        }
+    }
+    async loadTimeline(reset, sources) {
+        if (sources === undefined) {
+            if (reset) {
+                this.clear(true);
+            }
+            if (this.uri?.scheme === Schemas.vscodeSettings || this.uri?.scheme === Schemas.webviewPanel || this.uri?.scheme === Schemas.walkThrough) {
+                this.uri = undefined;
+                this.clear(false);
+                this.refresh();
+                return;
+            }
+            if (this._isEmpty && this.uri !== undefined) {
+                this.setLoadingUriMessage();
+            }
+        }
+        if (this.uri === undefined) {
+            this.clear(false);
+            this.refresh();
+            return;
+        }
+        if (!this.isBodyVisible()) {
+            return;
+        }
+        let hasPendingRequests = false;
+        for (const source of sources ?? ( this.timelineService.getSources().map(s => s.id))) {
+            const requested = this.loadTimelineForSource(source, this.uri, reset);
+            if (requested) {
+                hasPendingRequests = true;
+            }
+        }
+        if (!hasPendingRequests) {
+            this.refresh();
+        }
+        else if (this._isEmpty) {
+            this.setLoadingUriMessage();
+        }
+    }
+    loadTimelineForSource(source, uri, reset, options) {
+        if (( this.excludedSources.has(source))) {
+            return false;
+        }
+        const timeline = this.timelinesBySource.get(source);
+        if (!reset &&
+            options?.cursor !== undefined &&
+            timeline !== undefined &&
+            (!timeline?.more || timeline.items.length > timeline.lastRenderedIndex + this.pageSize)) {
+            return false;
+        }
+        if (options === undefined) {
+            options = { cursor: reset ? undefined : timeline?.cursor, limit: this.pageSize };
+        }
+        let request = this.pendingRequests.get(source);
+        if (request !== undefined) {
+            options.cursor = request.options.cursor;
+            if (typeof options.limit === 'number') {
+                if (typeof request.options.limit === 'number') {
+                    options.limit += request.options.limit;
+                }
+                else {
+                    options.limit = request.options.limit;
+                }
+            }
+        }
+        request?.tokenSource.dispose(true);
+        options.cacheResults = true;
+        options.resetCache = reset;
+        request = this.timelineService.getTimeline(source, uri, options, ( new CancellationTokenSource()));
+        if (request === undefined) {
+            return false;
+        }
+        this.pendingRequests.set(source, request);
+        request.tokenSource.token.onCancellationRequested(() => this.pendingRequests.delete(source));
+        this.handleRequest(request);
+        return true;
+    }
+    updateTimeline(timeline, reset) {
+        if (reset) {
+            this.timelinesBySource.delete(timeline.source);
+            const { oldest } = timeline;
+            this.loadTimelineForSource(timeline.source, this.uri, true, oldest !== undefined ? { limit: { timestamp: oldest.timestamp, id: oldest.id } } : undefined);
+        }
+        else {
+            const { newest } = timeline;
+            this.loadTimelineForSource(timeline.source, this.uri, false, newest !== undefined ? { limit: { timestamp: newest.timestamp, id: newest.id } } : { limit: this.pageSize });
+        }
+    }
+    async handleRequest(request) {
+        let response;
+        try {
+            response = await this.progressService.withProgress({ location: this.id }, () => request.result);
+        }
+        finally {
+            this.pendingRequests.delete(request.source);
+        }
+        if (response === undefined ||
+            request.tokenSource.token.isCancellationRequested ||
+            request.uri !== this.uri) {
+            if (this.pendingRequests.size === 0 && this._pendingRefresh) {
+                this.refresh();
+            }
+            return;
+        }
+        const source = request.source;
+        let updated = false;
+        const timeline = this.timelinesBySource.get(source);
+        if (timeline === undefined) {
+            this.timelinesBySource.set(source, ( new TimelineAggregate(response)));
+            updated = true;
+        }
+        else {
+            updated = timeline.add(response, request.options);
+        }
+        if (updated) {
+            this._pendingRefresh = true;
+            if (this.hasVisibleItems && this.pendingRequests.size !== 0) {
+                this.refreshDebounced();
+            }
+            else {
+                this.refresh();
+            }
+        }
+        else if (this.pendingRequests.size === 0) {
+            if (this._pendingRefresh) {
+                this.refresh();
+            }
+            else {
+                this.tree.rerender();
+            }
+        }
+    }
+    *getItems() {
+        let more = false;
+        if (this.uri === undefined || this.timelinesBySource.size === 0) {
+            this._visibleItemCount = 0;
+            return;
+        }
+        const maxCount = this._maxItemCount;
+        let count = 0;
+        if (this.timelinesBySource.size === 1) {
+            const [source, timeline] = Iterable.first(this.timelinesBySource);
+            timeline.lastRenderedIndex = -1;
+            if (( this.excludedSources.has(source))) {
+                this._visibleItemCount = 0;
+                return;
+            }
+            if (timeline.items.length !== 0) {
+                this._visibleItemCount = 1;
+            }
+            more = timeline.more;
+            let lastRelativeTime;
+            for (const item of timeline.items) {
+                item.relativeTime = undefined;
+                item.hideRelativeTime = undefined;
+                count++;
+                if (count > maxCount) {
+                    more = true;
+                    break;
+                }
+                lastRelativeTime = updateRelativeTime(item, lastRelativeTime);
+                yield { element: item };
+            }
+            timeline.lastRenderedIndex = count - 1;
+        }
+        else {
+            const sources = [];
+            let hasAnyItems = false;
+            let mostRecentEnd = 0;
+            for (const [source, timeline] of this.timelinesBySource) {
+                timeline.lastRenderedIndex = -1;
+                if (( this.excludedSources.has(source)) || timeline.stale) {
+                    continue;
+                }
+                if (timeline.items.length !== 0) {
+                    hasAnyItems = true;
+                }
+                if (timeline.more) {
+                    more = true;
+                    const last = timeline.items[Math.min(maxCount, timeline.items.length - 1)];
+                    if (last.timestamp > mostRecentEnd) {
+                        mostRecentEnd = last.timestamp;
+                    }
+                }
+                const iterator = timeline.items[Symbol.iterator]();
+                sources.push({ timeline, iterator, nextItem: iterator.next() });
+            }
+            this._visibleItemCount = hasAnyItems ? 1 : 0;
+            function getNextMostRecentSource() {
+                return sources
+                    .filter(source => !source.nextItem.done)
+                    .reduce((previous, current) => (previous === undefined || current.nextItem.value.timestamp >= previous.nextItem.value.timestamp) ? current : previous, undefined);
+            }
+            let lastRelativeTime;
+            let nextSource;
+            while (nextSource = getNextMostRecentSource()) {
+                nextSource.timeline.lastRenderedIndex++;
+                const item = nextSource.nextItem.value;
+                item.relativeTime = undefined;
+                item.hideRelativeTime = undefined;
+                if (item.timestamp >= mostRecentEnd) {
+                    count++;
+                    if (count > maxCount) {
+                        more = true;
+                        break;
+                    }
+                    lastRelativeTime = updateRelativeTime(item, lastRelativeTime);
+                    yield { element: item };
+                }
+                nextSource.nextItem = nextSource.iterator.next();
+            }
+        }
+        this._visibleItemCount = count;
+        if (count > 0) {
+            if (more) {
+                yield {
+                    element: ( new LoadMoreCommand(this.pendingRequests.size !== 0))
+                };
+            }
+            else if (this.pendingRequests.size !== 0) {
+                yield {
+                    element: ( new LoadMoreCommand(true))
+                };
+            }
+        }
+    }
+    refresh() {
+        if (!this.isBodyVisible()) {
+            return;
+        }
+        this.tree.setChildren(null, this.getItems());
+        this._isEmpty = !this.hasVisibleItems;
+        if (this.uri === undefined) {
+            this.updateFilename(undefined);
+            this.message = ( localizeWithPath(
+                'vs/workbench/contrib/timeline/browser/timelinePane',
+                'timeline.editorCannotProvideTimeline',
+                "The active editor cannot provide timeline information."
+            ));
+        }
+        else if (this._isEmpty) {
+            if (this.pendingRequests.size !== 0) {
+                this.setLoadingUriMessage();
+            }
+            else {
+                this.updateFilename(this.labelService.getUriBasenameLabel(this.uri));
+                const scmProviderCount = this.contextKeyService.getContextKeyValue('scm.providerCount');
+                if (this.timelineService.getSources().filter(({ id }) => !( this.excludedSources.has(id))).length === 0) {
+                    this.message = ( localizeWithPath(
+                        'vs/workbench/contrib/timeline/browser/timelinePane',
+                        'timeline.noTimelineSourcesEnabled',
+                        "All timeline sources have been filtered out."
+                    ));
+                }
+                else {
+                    if (this.configurationService.getValue('workbench.localHistory.enabled') && !( this.excludedSources.has('timeline.localHistory'))) {
+                        this.message = ( localizeWithPath(
+                            'vs/workbench/contrib/timeline/browser/timelinePane',
+                            'timeline.noLocalHistoryYet',
+                            "Local History will track recent changes as you save them unless the file has been excluded or is too large."
+                        ));
+                    }
+                    else if (this.excludedSources.size > 0) {
+                        this.message = ( localizeWithPath(
+                            'vs/workbench/contrib/timeline/browser/timelinePane',
+                            'timeline.noTimelineInfoFromEnabledSources',
+                            "No filtered timeline information was provided."
+                        ));
+                    }
+                    else {
+                        this.message = ( localizeWithPath(
+                            'vs/workbench/contrib/timeline/browser/timelinePane',
+                            'timeline.noTimelineInfo',
+                            "No timeline information was provided."
+                        ));
+                    }
+                }
+                if (!scmProviderCount || scmProviderCount === 0) {
+                    this.message += ' ' + ( localizeWithPath(
+                        'vs/workbench/contrib/timeline/browser/timelinePane',
+                        'timeline.noSCM',
+                        "Source Control has not been configured."
+                    ));
+                }
+            }
+        }
+        else {
+            this.updateFilename(this.labelService.getUriBasenameLabel(this.uri));
+            this.message = undefined;
+        }
+        this._pendingRefresh = false;
+    }
+    refreshDebounced() {
+        this.refresh();
+    }
+    focus() {
+        super.focus();
+        this.tree.domFocus();
+    }
+    setExpanded(expanded) {
+        const changed = super.setExpanded(expanded);
+        if (changed && this.isBodyVisible()) {
+            if (!this.followActiveEditor) {
+                this.setUriCore(this.uri, true);
+            }
+            else {
+                this.onActiveEditorChanged();
+            }
+        }
+        return changed;
+    }
+    setVisible(visible) {
+        if (visible) {
+            this.extensionService.activateByEvent('onView:timeline');
+            this.visibilityDisposables = ( new DisposableStore());
+            this.editorService.onDidActiveEditorChange(this.onActiveEditorChanged, this, this.visibilityDisposables);
+            this.onDidFocus(() => this.refreshDebounced(), this, this.visibilityDisposables);
+            super.setVisible(visible);
+            this.onActiveEditorChanged();
+        }
+        else {
+            this.visibilityDisposables?.dispose();
+            super.setVisible(visible);
+        }
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.tree.layout(height, width);
+    }
+    renderHeaderTitle(container) {
+        super.renderHeaderTitle(container, this.title);
+        container.classList.add('timeline-view');
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.$container = container;
+        container.classList.add('tree-explorer-viewlet-tree-view', 'timeline-tree-view');
+        this.$message = append(this.$container, $('.message'));
+        this.$message.classList.add('timeline-subtle');
+        this.message = ( localizeWithPath(
+            'vs/workbench/contrib/timeline/browser/timelinePane',
+            'timeline.editorCannotProvideTimeline',
+            "The active editor cannot provide timeline information."
+        ));
+        this.$tree = document.createElement('div');
+        this.$tree.classList.add('customview-tree', 'file-icon-themable-tree', 'hide-arrows');
+        container.appendChild(this.$tree);
+        this.treeRenderer = this.instantiationService.createInstance(TimelineTreeRenderer, this.commands);
+        this.treeRenderer.onDidScrollToEnd(item => {
+            if (this.pageOnScroll) {
+                this.loadMore(item);
+            }
+        });
+        this.tree = this.instantiationService.createInstance(WorkbenchObjectTree, 'TimelinePane', this.$tree, ( new TimelineListVirtualDelegate()), [this.treeRenderer], {
+            identityProvider: ( new TimelineIdentityProvider()),
+            accessibilityProvider: {
+                getAriaLabel(element) {
+                    if (isLoadMoreCommand(element)) {
+                        return element.ariaLabel;
+                    }
+                    return element.accessibilityInformation ? element.accessibilityInformation.label : ( localizeWithPath(
+                        'vs/workbench/contrib/timeline/browser/timelinePane',
+                        'timeline.aria.item',
+                        "{0}: {1}",
+                        element.relativeTimeFullWord ?? '',
+                        element.label
+                    ));
+                },
+                getRole(element) {
+                    if (isLoadMoreCommand(element)) {
+                        return 'treeitem';
+                    }
+                    return element.accessibilityInformation && element.accessibilityInformation.role ? element.accessibilityInformation.role : 'treeitem';
+                },
+                getWidgetAriaLabel() {
+                    return ( localizeWithPath(
+                        'vs/workbench/contrib/timeline/browser/timelinePane',
+                        'timeline',
+                        "Timeline"
+                    ));
+                }
+            },
+            keyboardNavigationLabelProvider: ( new TimelineKeyboardNavigationLabelProvider()),
+            multipleSelectionSupport: false,
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            }
+        });
+        this._register(this.tree.onContextMenu(e => this.onContextMenu(this.commands, e)));
+        this._register(this.tree.onDidChangeSelection(e => this.ensureValidItems()));
+        this._register(this.tree.onDidOpen(e => {
+            if (!e.browserEvent || !this.ensureValidItems()) {
+                return;
+            }
+            const selection = this.tree.getSelection();
+            let item;
+            if (selection.length === 1) {
+                item = selection[0];
+            }
+            if (item === null) {
+                return;
+            }
+            if (isTimelineItem(item)) {
+                if (item.command) {
+                    let args = item.command.arguments ?? [];
+                    if (item.command.id === API_OPEN_EDITOR_COMMAND_ID || item.command.id === API_OPEN_DIFF_EDITOR_COMMAND_ID) {
+                        args = [...args, e];
+                    }
+                    this.commandService.executeCommand(item.command.id, ...args);
+                }
+            }
+            else if (isLoadMoreCommand(item)) {
+                this.loadMore(item);
+            }
+        }));
+    }
+    loadMore(item) {
+        if (item.loading) {
+            return;
+        }
+        item.loading = true;
+        this.tree.rerender(item);
+        if (this.pendingRequests.size !== 0) {
+            return;
+        }
+        this._maxItemCount = this._visibleItemCount + this.pageSize;
+        this.loadTimeline(false);
+    }
+    ensureValidItems() {
+        if (!this.hasVisibleItems || !( this.timelineService.getSources().some(({ id }) => !( this.excludedSources.has(id)) && ( this.timelinesBySource.has(id))))) {
+            this.tree.setChildren(null, undefined);
+            this._isEmpty = true;
+            this.setLoadingUriMessage();
+            return false;
+        }
+        return true;
+    }
+    setLoadingUriMessage() {
+        const file = this.uri && this.labelService.getUriBasenameLabel(this.uri);
+        this.updateFilename(file);
+        this.message = file ? ( localizeWithPath(
+            'vs/workbench/contrib/timeline/browser/timelinePane',
+            'timeline.loading',
+            "Loading timeline for {0}...",
+            file
+        )) : '';
+    }
+    onContextMenu(commands, treeEvent) {
+        const item = treeEvent.element;
+        if (item === null) {
+            return;
+        }
+        const event = treeEvent.browserEvent;
+        event.preventDefault();
+        event.stopPropagation();
+        if (!this.ensureValidItems()) {
+            return;
+        }
+        this.tree.setFocus([item]);
+        const actions = commands.getItemContextActions(item);
+        if (!actions.length) {
+            return;
+        }
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => treeEvent.anchor,
+            getActions: () => actions,
+            getActionViewItem: (action) => {
+                const keybinding = this.keybindingService.lookupKeybinding(action.id);
+                if (keybinding) {
+                    return ( new ActionViewItem(action, action, { label: true, keybinding: keybinding.getLabel() }));
+                }
+                return undefined;
+            },
+            onHide: (wasCancelled) => {
+                if (wasCancelled) {
+                    this.tree.domFocus();
+                }
+            },
+            getActionsContext: () => ({ uri: this.uri, item }),
+            actionRunner: ( new TimelineActionRunner())
+        });
+    }
+};
+TimelinePane.__decorator = ( __decorate([
+    debounce(500)
+], TimelinePane.prototype, "refreshDebounced", null));
+TimelinePane = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IViewDescriptorService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IEditorService)),
+    ( __param(9, ICommandService)),
+    ( __param(10, IProgressService)),
+    ( __param(11, ITimelineService)),
+    ( __param(12, IOpenerService)),
+    ( __param(13, IThemeService)),
+    ( __param(14, ITelemetryService)),
+    ( __param(15, ILabelService)),
+    ( __param(16, IUriIdentityService)),
+    ( __param(17, IExtensionService))
+], TimelinePane));
+class TimelineElementTemplate {
+    static { this.id = 'TimelineElementTemplate'; }
+    constructor(container, actionViewItemProvider, hoverDelegate) {
+        container.classList.add('custom-view-tree-node-item');
+        this.icon = append(container, $('.custom-view-tree-node-item-icon'));
+        this.iconLabel = ( new IconLabel(container, { supportHighlights: true, supportIcons: true, hoverDelegate }));
+        const timestampContainer = append(this.iconLabel.element, $('.timeline-timestamp-container'));
+        this.timestamp = append(timestampContainer, $('span.timeline-timestamp'));
+        const actionsContainer = append(this.iconLabel.element, $('.actions'));
+        this.actionBar = ( new ActionBar(actionsContainer, { actionViewItemProvider }));
+    }
+    dispose() {
+        this.iconLabel.dispose();
+        this.actionBar.dispose();
+    }
+    reset() {
+        this.icon.className = '';
+        this.icon.style.backgroundImage = '';
+        this.actionBar.clear();
+    }
+}
+class TimelineIdentityProvider {
+    getId(item) {
+        return item.handle;
+    }
+}
+class TimelineActionRunner extends ActionRunner {
+    async runAction(action, { uri, item }) {
+        if (!isTimelineItem(item)) {
+            await action.run();
+            return;
+        }
+        await action.run({
+            $mid: 12 ,
+            handle: item.handle,
+            source: item.source,
+            uri
+        }, uri, item.source);
+    }
+}
+class TimelineKeyboardNavigationLabelProvider {
+    getKeyboardNavigationLabel(element) {
+        return element.label;
+    }
+}
+class TimelineListVirtualDelegate {
+    getHeight(_element) {
+        return ItemHeight;
+    }
+    getTemplateId(element) {
+        return TimelineElementTemplate.id;
+    }
+}
+let TimelineTreeRenderer = class TimelineTreeRenderer {
+    constructor(commands, instantiationService, themeService) {
+        this.commands = commands;
+        this.instantiationService = instantiationService;
+        this.themeService = themeService;
+        this._onDidScrollToEnd = ( new Emitter());
+        this.onDidScrollToEnd = this._onDidScrollToEnd.event;
+        this.templateId = TimelineElementTemplate.id;
+        this.actionViewItemProvider = createActionViewItem.bind(undefined, this.instantiationService);
+        this._hoverDelegate = getDefaultHoverDelegate('mouse');
+    }
+    setUri(uri) {
+        this.uri = uri;
+    }
+    renderTemplate(container) {
+        return ( new TimelineElementTemplate(container, this.actionViewItemProvider, this._hoverDelegate));
+    }
+    renderElement(node, index, template, height) {
+        template.reset();
+        const { element: item } = node;
+        const theme = this.themeService.getColorTheme();
+        const icon = theme.type === ColorScheme.LIGHT ? item.icon : item.iconDark;
+        const iconUrl = icon ? URI.revive(icon) : null;
+        if (iconUrl) {
+            template.icon.className = 'custom-view-tree-node-item-icon';
+            template.icon.style.backgroundImage = asCSSUrl(iconUrl);
+            template.icon.style.color = '';
+        }
+        else if (item.themeIcon) {
+            template.icon.className = `custom-view-tree-node-item-icon ${ThemeIcon.asClassName(item.themeIcon)}`;
+            if (item.themeIcon.color) {
+                template.icon.style.color = theme.getColor(item.themeIcon.color.id)?.toString() ?? '';
+            }
+            else {
+                template.icon.style.color = '';
+            }
+            template.icon.style.backgroundImage = '';
+        }
+        else {
+            template.icon.className = 'custom-view-tree-node-item-icon';
+            template.icon.style.backgroundImage = '';
+            template.icon.style.color = '';
+        }
+        const tooltip = item.tooltip
+            ? isString(item.tooltip)
+                ? item.tooltip
+                : { markdown: item.tooltip, markdownNotSupportedFallback: renderMarkdownAsPlaintext(item.tooltip) }
+            : undefined;
+        template.iconLabel.setLabel(item.label, item.description, {
+            title: tooltip,
+            matches: createMatches(node.filterData)
+        });
+        template.timestamp.textContent = item.relativeTime ?? '';
+        template.timestamp.ariaLabel = item.relativeTimeFullWord ?? '';
+        template.timestamp.parentElement.classList.toggle('timeline-timestamp--duplicate', isTimelineItem(item) && item.hideRelativeTime);
+        template.actionBar.context = { uri: this.uri, item };
+        template.actionBar.actionRunner = ( new TimelineActionRunner());
+        template.actionBar.push(this.commands.getItemActions(item), { icon: true, label: false });
+        if (isLoadMoreCommand(item)) {
+            setTimeout(() => this._onDidScrollToEnd.fire(item), 0);
+        }
+    }
+    disposeTemplate(template) {
+        template.dispose();
+    }
+};
+TimelineTreeRenderer = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IThemeService))
+], TimelineTreeRenderer));
+const timelineRefresh = registerIcon('timeline-refresh', Codicon.refresh, ( localizeWithPath(
+    'vs/workbench/contrib/timeline/browser/timelinePane',
+    'timelineRefresh',
+    'Icon for the refresh timeline action.'
+)));
+const timelinePin = registerIcon('timeline-pin', Codicon.pin, ( localizeWithPath(
+    'vs/workbench/contrib/timeline/browser/timelinePane',
+    'timelinePin',
+    'Icon for the pin timeline action.'
+)));
+const timelineUnpin = registerIcon('timeline-unpin', Codicon.pinned, ( localizeWithPath(
+    'vs/workbench/contrib/timeline/browser/timelinePane',
+    'timelineUnpin',
+    'Icon for the unpin timeline action.'
+)));
+let TimelinePaneCommands = class TimelinePaneCommands extends Disposable {
+    constructor(pane, timelineService, storageService, contextKeyService, menuService) {
+        super();
+        this.pane = pane;
+        this.timelineService = timelineService;
+        this.storageService = storageService;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+        this._register(this.sourceDisposables = ( new DisposableStore()));
+        this._register(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'timeline.refresh',
+                    title: ( localize2WithPath('vs/workbench/contrib/timeline/browser/timelinePane', 'refresh', "Refresh")),
+                    icon: timelineRefresh,
+                    category: ( localize2WithPath(
+                        'vs/workbench/contrib/timeline/browser/timelinePane',
+                        'timeline',
+                        "Timeline"
+                    )),
+                    menu: {
+                        id: MenuId.TimelineTitle,
+                        group: 'navigation',
+                        order: 99,
+                    }
+                });
+            }
+            run(accessor, ...args) {
+                pane.reset();
+            }
+        }));
+        this._register(CommandsRegistry.registerCommand('timeline.toggleFollowActiveEditor', (accessor, ...args) => pane.followActiveEditor = !pane.followActiveEditor));
+        this._register(MenuRegistry.appendMenuItem(MenuId.TimelineTitle, ({
+            command: {
+                id: 'timeline.toggleFollowActiveEditor',
+                title: ( localize2WithPath(
+                    'vs/workbench/contrib/timeline/browser/timelinePane',
+                    'timeline.toggleFollowActiveEditorCommand.follow',
+                    'Pin the Current Timeline'
+                )),
+                icon: timelinePin,
+                category: ( localize2WithPath(
+                    'vs/workbench/contrib/timeline/browser/timelinePane',
+                    'timeline',
+                    "Timeline"
+                )),
+            },
+            group: 'navigation',
+            order: 98,
+            when: TimelineFollowActiveEditorContext
+        })));
+        this._register(MenuRegistry.appendMenuItem(MenuId.TimelineTitle, ({
+            command: {
+                id: 'timeline.toggleFollowActiveEditor',
+                title: ( localize2WithPath(
+                    'vs/workbench/contrib/timeline/browser/timelinePane',
+                    'timeline.toggleFollowActiveEditorCommand.unfollow',
+                    'Unpin the Current Timeline'
+                )),
+                icon: timelineUnpin,
+                category: ( localize2WithPath(
+                    'vs/workbench/contrib/timeline/browser/timelinePane',
+                    'timeline',
+                    "Timeline"
+                )),
+            },
+            group: 'navigation',
+            order: 98,
+            when: ( TimelineFollowActiveEditorContext.toNegated())
+        })));
+        this._register(timelineService.onDidChangeProviders(() => this.updateTimelineSourceFilters()));
+        this.updateTimelineSourceFilters();
+    }
+    getItemActions(element) {
+        return this.getActions(MenuId.TimelineItemContext, { key: 'timelineItem', value: element.contextValue }).primary;
+    }
+    getItemContextActions(element) {
+        return this.getActions(MenuId.TimelineItemContext, { key: 'timelineItem', value: element.contextValue }).secondary;
+    }
+    getActions(menuId, context) {
+        const contextKeyService = this.contextKeyService.createOverlay([
+            ['view', this.pane.id],
+            [context.key, context.value],
+        ]);
+        const menu = this.menuService.createMenu(menuId, contextKeyService);
+        const primary = [];
+        const secondary = [];
+        const result = { primary, secondary };
+        createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline');
+        menu.dispose();
+        return result;
+    }
+    updateTimelineSourceFilters() {
+        this.sourceDisposables.clear();
+        const excluded = ( new Set(
+            JSON.parse(this.storageService.get('timeline.excludeSources', 0 , '[]'))
+        ));
+        for (const source of this.timelineService.getSources()) {
+            this.sourceDisposables.add(registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: `timeline.toggleExcludeSource:${source.id}`,
+                        title: source.label,
+                        menu: {
+                            id: MenuId.TimelineFilterSubMenu,
+                            group: 'navigation',
+                        },
+                        toggled: ( ( ContextKeyExpr.regex(`timelineExcludeSources`, ( new RegExp(`\\b${escapeRegExpCharacters(source.id)}\\b`)))).negate())
+                    });
+                }
+                run(accessor, ...args) {
+                    if (( excluded.has(source.id))) {
+                        excluded.delete(source.id);
+                    }
+                    else {
+                        excluded.add(source.id);
+                    }
+                    const storageService = accessor.get(IStorageService);
+                    storageService.store('timeline.excludeSources', JSON.stringify([...( excluded.keys())]), 0 , 0 );
+                }
+            }));
+        }
+    }
+};
+TimelinePaneCommands = ( __decorate([
+    ( __param(1, ITimelineService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IMenuService))
+], TimelinePaneCommands));
+export { TimelineExcludeSources, TimelineFollowActiveEditorContext, TimelineIdentityProvider, TimelineKeyboardNavigationLabelProvider, TimelineListVirtualDelegate, TimelinePane };