@codingame/monaco-vscode-api 2.1.3 → 2.2.0-next.1

package/vscode/src/vs/workbench/contrib/callHierarchy/browser/callHierarchyTree.js

@@ -0,0 +1,133 @@
+import { CallHierarchyModel } from '../common/callHierarchy.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { createMatches } from '../../../../base/common/filters.js';
+import { IconLabel } from '../../../../base/browser/ui/iconLabel/iconLabel.js';
+import { SymbolKinds } from '../../../../editor/common/languages.js';
+import { compare } from '../../../../base/common/strings.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+class Call {
+    constructor(item, locations, model, parent) {
+        this.item = item;
+        this.locations = locations;
+        this.model = model;
+        this.parent = parent;
+    }
+    static compare(a, b) {
+        let res = compare(( a.item.uri.toString()), ( b.item.uri.toString()));
+        if (res === 0) {
+            res = Range.compareRangesUsingStarts(a.item.range, b.item.range);
+        }
+        return res;
+    }
+}
+class DataSource {
+    constructor(getDirection) {
+        this.getDirection = getDirection;
+    }
+    hasChildren() {
+        return true;
+    }
+    async getChildren(element) {
+        if (element instanceof CallHierarchyModel) {
+            return ( element.roots.map(root => ( new Call(root, undefined, element, undefined))));
+        }
+        const { model, item } = element;
+        if (this.getDirection() === "outgoingCalls" ) {
+            return ( (await model.resolveOutgoingCalls(item, CancellationToken.None)).map(call => {
+                return ( new Call(call.to, ( call.fromRanges.map(range => ({ range, uri: item.uri }))), model, element));
+            }));
+        }
+        else {
+            return ( (await model.resolveIncomingCalls(item, CancellationToken.None)).map(call => {
+                return ( new Call(call.from, ( call.fromRanges.map(range => ({ range, uri: call.from.uri }))), model, element));
+            }));
+        }
+    }
+}
+class Sorter {
+    compare(element, otherElement) {
+        return Call.compare(element, otherElement);
+    }
+}
+class IdentityProvider {
+    constructor(getDirection) {
+        this.getDirection = getDirection;
+    }
+    getId(element) {
+        let res = this.getDirection() + JSON.stringify(element.item.uri) + JSON.stringify(element.item.range);
+        if (element.parent) {
+            res += this.getId(element.parent);
+        }
+        return res;
+    }
+}
+class CallRenderingTemplate {
+    constructor(icon, label) {
+        this.icon = icon;
+        this.label = label;
+    }
+}
+class CallRenderer {
+    constructor() {
+        this.templateId = CallRenderer.id;
+    }
+    static { this.id = 'CallRenderer'; }
+    renderTemplate(container) {
+        container.classList.add('callhierarchy-element');
+        const icon = document.createElement('div');
+        container.appendChild(icon);
+        const label = ( new IconLabel(container, { supportHighlights: true }));
+        return ( new CallRenderingTemplate(icon, label));
+    }
+    renderElement(node, _index, template) {
+        const { element, filterData } = node;
+        const deprecated = element.item.tags?.includes(1 );
+        template.icon.className = '';
+        template.icon.classList.add('inline', ...ThemeIcon.asClassNameArray(SymbolKinds.toIcon(element.item.kind)));
+        template.label.setLabel(element.item.name, element.item.detail, { labelEscapeNewLines: true, matches: createMatches(filterData), strikethrough: deprecated });
+    }
+    disposeTemplate(template) {
+        template.label.dispose();
+    }
+}
+class VirtualDelegate {
+    getHeight(_element) {
+        return 22;
+    }
+    getTemplateId(_element) {
+        return CallRenderer.id;
+    }
+}
+class AccessibilityProvider {
+    constructor(getDirection) {
+        this.getDirection = getDirection;
+    }
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/callHierarchy/browser/callHierarchyTree',
+            'tree.aria',
+            "Call Hierarchy"
+        ));
+    }
+    getAriaLabel(element) {
+        if (this.getDirection() === "outgoingCalls" ) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchyTree',
+                'from',
+                "calls from {0}",
+                element.item.name
+            ));
+        }
+        else {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchyTree',
+                'to',
+                "callers of {0}",
+                element.item.name
+            ));
+        }
+    }
+}
+export { AccessibilityProvider, Call, CallRenderer, DataSource, IdentityProvider, Sorter, VirtualDelegate };

package/vscode/src/vs/workbench/contrib/callHierarchy/browser/media/callHierarchy.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .call-hierarchy .message,.monaco-workbench .call-hierarchy .results{display:none}.monaco-workbench .call-hierarchy[data-state=data] .results{display:inherit;height:100%}.monaco-workbench .call-hierarchy[data-state=message] .message{align-items:center;display:flex;height:100%;justify-content:center}.monaco-workbench .call-hierarchy .editor,.monaco-workbench .call-hierarchy .tree{height:100%}.monaco-editor .call-hierarchy .tree{background-color:var(--vscode-peekViewResult-background);color:var(--vscode-peekViewResult-fileForeground)}.monaco-workbench .call-hierarchy .tree .callhierarchy-element{align-items:center;display:flex;flex:1;flex-flow:row nowrap}.monaco-workbench .call-hierarchy .tree .callhierarchy-element .monaco-icon-label{padding-left:4px}.monaco-editor .call-hierarchy .tree .monaco-list:focus .monaco-list-rows>.monaco-list-row.selected:not(.highlighted){background-color:var(--vscode-peekViewResult-selectionBackground);color:var(--vscode-peekViewResult-selectionForeground)!important}.monaco-editor .call-hierarchy .call-decoration{background-color:var(--vscode-peekViewEditor-matchHighlightBackground);border:2px solid var(--vscode-peekViewEditor-matchHighlightBorder);box-sizing:border-box}.monaco-editor .call-hierarchy .editor .monaco-editor .inputarea.ime-input,.monaco-editor .call-hierarchy .editor .monaco-editor .monaco-editor-background{background-color:var(--vscode-peekViewEditor-background)}.monaco-editor .call-hierarchy .editor .monaco-editor .margin{background-color:var(--vscode-peekViewEditorGutter-background)}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/comments/browser/commentGlyphWidget.js

@@ -0,0 +1,90 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { Color } from '../../../../base/common/color.js';
+import { OverviewRulerLane } from '../../../../editor/common/model.js';
+import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
+import { registerColor, opaque, darken, editorForeground, editorBackground, listInactiveSelectionBackground } from '../../../../platform/theme/common/colorRegistry.js';
+import { themeColorFromId } from '../../../../platform/theme/common/themeService.js';
+import { CommentThreadState } from '../../../../editor/common/languages.js';
+const overviewRulerCommentingRangeForeground = registerColor('editorGutter.commentRangeForeground', { dark: opaque(listInactiveSelectionBackground, editorBackground), light: ( darken(opaque(listInactiveSelectionBackground, editorBackground), .05)), hcDark: Color.white, hcLight: Color.black }, ( localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentGlyphWidget',
+    'editorGutterCommentRangeForeground',
+    'Editor gutter decoration color for commenting ranges. This color should be opaque.'
+)));
+const overviewRulerCommentForeground = registerColor('editorOverviewRuler.commentForeground', { dark: overviewRulerCommentingRangeForeground, light: overviewRulerCommentingRangeForeground, hcDark: overviewRulerCommentingRangeForeground, hcLight: overviewRulerCommentingRangeForeground }, ( localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentGlyphWidget',
+    'editorOverviewRuler.commentForeground',
+    'Editor overview ruler decoration color for resolved comments. This color should be opaque.'
+)));
+const overviewRulerCommentUnresolvedForeground = registerColor('editorOverviewRuler.commentUnresolvedForeground', { dark: overviewRulerCommentForeground, light: overviewRulerCommentForeground, hcDark: overviewRulerCommentForeground, hcLight: overviewRulerCommentForeground }, ( localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentGlyphWidget',
+    'editorOverviewRuler.commentUnresolvedForeground',
+    'Editor overview ruler decoration color for unresolved comments. This color should be opaque.'
+)));
+const editorGutterCommentGlyphForeground = registerColor('editorGutter.commentGlyphForeground', { dark: editorForeground, light: editorForeground, hcDark: Color.black, hcLight: Color.white }, ( localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentGlyphWidget',
+    'editorGutterCommentGlyphForeground',
+    'Editor gutter decoration color for commenting glyphs.'
+)));
+registerColor('editorGutter.commentUnresolvedGlyphForeground', { dark: editorGutterCommentGlyphForeground, light: editorGutterCommentGlyphForeground, hcDark: editorGutterCommentGlyphForeground, hcLight: editorGutterCommentGlyphForeground }, ( localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentGlyphWidget',
+    'editorGutterCommentUnresolvedGlyphForeground',
+    'Editor gutter decoration color for commenting glyphs for unresolved comment threads.'
+)));
+class CommentGlyphWidget {
+    static { this.description = 'comment-glyph-widget'; }
+    constructor(editor, lineNumber) {
+        this._commentsOptions = this.createDecorationOptions();
+        this._editor = editor;
+        this._commentsDecorations = this._editor.createDecorationsCollection();
+        this.setLineNumber(lineNumber);
+    }
+    createDecorationOptions() {
+        const unresolved = this._threadState === CommentThreadState.Unresolved;
+        const decorationOptions = {
+            description: CommentGlyphWidget.description,
+            isWholeLine: true,
+            overviewRuler: {
+                color: themeColorFromId(unresolved ? overviewRulerCommentUnresolvedForeground : overviewRulerCommentForeground),
+                position: OverviewRulerLane.Center
+            },
+            collapseOnReplaceEdit: true,
+            linesDecorationsClassName: `comment-range-glyph comment-thread${unresolved ? '-unresolved' : ''}`
+        };
+        return ModelDecorationOptions.createDynamic(decorationOptions);
+    }
+    setThreadState(state) {
+        if (this._threadState !== state) {
+            this._threadState = state;
+            this._commentsOptions = this.createDecorationOptions();
+            this._updateDecorations();
+        }
+    }
+    _updateDecorations() {
+        const commentsDecorations = [{
+                range: {
+                    startLineNumber: this._lineNumber, startColumn: 1,
+                    endLineNumber: this._lineNumber, endColumn: 1
+                },
+                options: this._commentsOptions
+            }];
+        this._commentsDecorations.set(commentsDecorations);
+    }
+    setLineNumber(lineNumber) {
+        this._lineNumber = lineNumber;
+        this._updateDecorations();
+    }
+    getPosition() {
+        const range = (this._commentsDecorations.length > 0 ? this._commentsDecorations.getRange(0) : null);
+        return {
+            position: {
+                lineNumber: range ? range.endLineNumber : this._lineNumber,
+                column: 1
+            },
+            preference: [0 ]
+        };
+    }
+    dispose() {
+        this._commentsDecorations.clear();
+    }
+}
+export { CommentGlyphWidget, overviewRulerCommentingRangeForeground };

package/vscode/src/vs/workbench/contrib/comments/browser/commentMenus.js

@@ -0,0 +1,43 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { MenuId, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { createAndFillInContextMenuActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+let CommentMenus = class CommentMenus {
+    constructor(menuService) {
+        this.menuService = menuService;
+    }
+    getCommentThreadTitleActions(contextKeyService) {
+        return this.getMenu(MenuId.CommentThreadTitle, contextKeyService);
+    }
+    getCommentThreadActions(contextKeyService) {
+        return this.getMenu(MenuId.CommentThreadActions, contextKeyService);
+    }
+    getCommentEditorActions(contextKeyService) {
+        return this.getMenu(MenuId.CommentEditorActions, contextKeyService);
+    }
+    getCommentThreadAdditionalActions(contextKeyService) {
+        return this.getMenu(MenuId.CommentThreadAdditionalActions, contextKeyService);
+    }
+    getCommentTitleActions(comment, contextKeyService) {
+        return this.getMenu(MenuId.CommentTitle, contextKeyService);
+    }
+    getCommentActions(comment, contextKeyService) {
+        return this.getMenu(MenuId.CommentActions, contextKeyService);
+    }
+    getCommentThreadTitleContextActions(contextKeyService) {
+        return this.getMenu(MenuId.CommentThreadTitleContext, contextKeyService);
+    }
+    getMenu(menuId, contextKeyService) {
+        const menu = this.menuService.createMenu(menuId, contextKeyService);
+        const primary = [];
+        const secondary = [];
+        const result = { primary, secondary };
+        createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline');
+        return menu;
+    }
+    dispose() {
+    }
+};
+CommentMenus = ( __decorate([
+    ( __param(0, IMenuService))
+], CommentMenus));
+export { CommentMenus };

package/vscode/src/vs/workbench/contrib/comments/browser/commentService.js

@@ -1,3 +1,318 @@
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { CommentMenus } from './commentMenus.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { COMMENTS_SECTION } from '../common/commentsConfiguration.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { CommentContextKeys } from '../common/commentContextKeys.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { CommentsModel } from './commentsModel.js';
 const ICommentService = ( createDecorator('commentService'));
-export { ICommentService };
+const CONTINUE_ON_COMMENTS = 'comments.continueOnComments';
+let CommentService = class CommentService extends Disposable {
+    constructor(instantiationService, layoutService, configurationService, contextKeyService, storageService, logService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.layoutService = layoutService;
+        this.configurationService = configurationService;
+        this.storageService = storageService;
+        this.logService = logService;
+        this._onDidSetDataProvider = this._register(( new Emitter()));
+        this.onDidSetDataProvider = this._onDidSetDataProvider.event;
+        this._onDidDeleteDataProvider = this._register(( new Emitter()));
+        this.onDidDeleteDataProvider = this._onDidDeleteDataProvider.event;
+        this._onDidSetResourceCommentInfos = this._register(( new Emitter()));
+        this.onDidSetResourceCommentInfos = this._onDidSetResourceCommentInfos.event;
+        this._onDidSetAllCommentThreads = this._register(( new Emitter()));
+        this.onDidSetAllCommentThreads = this._onDidSetAllCommentThreads.event;
+        this._onDidUpdateCommentThreads = this._register(( new Emitter()));
+        this.onDidUpdateCommentThreads = this._onDidUpdateCommentThreads.event;
+        this._onDidUpdateNotebookCommentThreads = this._register(( new Emitter()));
+        this.onDidUpdateNotebookCommentThreads = this._onDidUpdateNotebookCommentThreads.event;
+        this._onDidUpdateCommentingRanges = this._register(( new Emitter()));
+        this.onDidUpdateCommentingRanges = this._onDidUpdateCommentingRanges.event;
+        this._onDidChangeActiveCommentThread = this._register(( new Emitter()));
+        this.onDidChangeActiveCommentThread = this._onDidChangeActiveCommentThread.event;
+        this._onDidChangeCurrentCommentThread = this._register(( new Emitter()));
+        this.onDidChangeCurrentCommentThread = this._onDidChangeCurrentCommentThread.event;
+        this._onDidChangeCommentingEnabled = this._register(( new Emitter()));
+        this.onDidChangeCommentingEnabled = this._onDidChangeCommentingEnabled.event;
+        this._onDidChangeActiveCommentingRange = this._register(( new Emitter()));
+        this.onDidChangeActiveCommentingRange = this._onDidChangeActiveCommentingRange.event;
+        this._commentControls = ( new Map());
+        this._commentMenus = ( new Map());
+        this._isCommentingEnabled = true;
+        this._continueOnComments = ( new Map());
+        this._continueOnCommentProviders = ( new Set());
+        this._commentsModel = this._register(( new CommentsModel()));
+        this.commentsModel = this._commentsModel;
+        this._handleConfiguration();
+        this._handleZenMode();
+        this._workspaceHasCommenting = CommentContextKeys.WorkspaceHasCommenting.bindTo(contextKeyService);
+        const storageListener = this._register(( new DisposableStore()));
+        const storageEvent = Event.debounce(this.storageService.onDidChangeValue(1 , CONTINUE_ON_COMMENTS, storageListener), (last, event) => last?.external ? last : event, 500);
+        storageListener.add(storageEvent(v => {
+            if (!v.external) {
+                return;
+            }
+            const commentsToRestore = this.storageService.getObject(CONTINUE_ON_COMMENTS, 1 );
+            if (!commentsToRestore) {
+                return;
+            }
+            this.logService.debug(`Comments: URIs of continue on comments from storage ${( commentsToRestore.map(thread => ( thread.uri.toString()))).join(', ')}.`);
+            const changedOwners = this._addContinueOnComments(commentsToRestore, this._continueOnComments);
+            for (const owner of changedOwners) {
+                const control = this._commentControls.get(owner);
+                if (!control) {
+                    continue;
+                }
+                const evt = {
+                    owner,
+                    ownerLabel: control.label,
+                    pending: this._continueOnComments.get(owner) || [],
+                    added: [],
+                    removed: [],
+                    changed: []
+                };
+                this.updateModelThreads(evt);
+            }
+        }));
+        this._register(storageService.onWillSaveState(() => {
+            const map = ( new Map());
+            for (const provider of this._continueOnCommentProviders) {
+                const pendingComments = provider.provideContinueOnComments();
+                this._addContinueOnComments(pendingComments, map);
+            }
+            this._saveContinueOnComments(map);
+        }));
+    }
+    _handleConfiguration() {
+        this._isCommentingEnabled = this._defaultCommentingEnablement;
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('comments.visible')) {
+                this.enableCommenting(this._defaultCommentingEnablement);
+            }
+        }));
+    }
+    _handleZenMode() {
+        let preZenModeValue = this._isCommentingEnabled;
+        this._register(this.layoutService.onDidChangeZenMode(e => {
+            if (e) {
+                preZenModeValue = this._isCommentingEnabled;
+                this.enableCommenting(false);
+            }
+            else {
+                this.enableCommenting(preZenModeValue);
+            }
+        }));
+    }
+    get _defaultCommentingEnablement() {
+        return !!this.configurationService.getValue(COMMENTS_SECTION)?.visible;
+    }
+    get isCommentingEnabled() {
+        return this._isCommentingEnabled;
+    }
+    enableCommenting(enable) {
+        if (enable !== this._isCommentingEnabled) {
+            this._isCommentingEnabled = enable;
+            this._onDidChangeCommentingEnabled.fire(enable);
+        }
+    }
+    setCurrentCommentThread(commentThread) {
+        this._onDidChangeCurrentCommentThread.fire(commentThread);
+    }
+    setActiveCommentThread(commentThread) {
+        this._onDidChangeActiveCommentThread.fire(commentThread);
+    }
+    setDocumentComments(resource, commentInfos) {
+        if (commentInfos.length) {
+            this._workspaceHasCommenting.set(true);
+        }
+        this._onDidSetResourceCommentInfos.fire({ resource, commentInfos });
+    }
+    setModelThreads(ownerId, ownerLabel, commentThreads) {
+        this._commentsModel.setCommentThreads(ownerId, ownerLabel, commentThreads);
+        this._onDidSetAllCommentThreads.fire({ ownerId, ownerLabel, commentThreads });
+    }
+    updateModelThreads(event) {
+        this._commentsModel.updateCommentThreads(event);
+        this._onDidUpdateCommentThreads.fire(event);
+    }
+    setWorkspaceComments(owner, commentsByResource) {
+        if (commentsByResource.length) {
+            this._workspaceHasCommenting.set(true);
+        }
+        const control = this._commentControls.get(owner);
+        if (control) {
+            this.setModelThreads(owner, control.label, commentsByResource);
+        }
+    }
+    removeWorkspaceComments(owner) {
+        const control = this._commentControls.get(owner);
+        if (control) {
+            this.setModelThreads(owner, control.label, []);
+        }
+    }
+    registerCommentController(owner, commentControl) {
+        this._commentControls.set(owner, commentControl);
+        this._onDidSetDataProvider.fire();
+    }
+    unregisterCommentController(owner) {
+        if (owner) {
+            this._commentControls.delete(owner);
+        }
+        else {
+            this._commentControls.clear();
+        }
+        this._commentsModel.deleteCommentsByOwner(owner);
+        this._onDidDeleteDataProvider.fire(owner);
+    }
+    getCommentController(owner) {
+        return this._commentControls.get(owner);
+    }
+    async createCommentThreadTemplate(owner, resource, range) {
+        const commentController = this._commentControls.get(owner);
+        if (!commentController) {
+            return;
+        }
+        return commentController.createCommentThreadTemplate(resource, range);
+    }
+    async updateCommentThreadTemplate(owner, threadHandle, range) {
+        const commentController = this._commentControls.get(owner);
+        if (!commentController) {
+            return;
+        }
+        await commentController.updateCommentThreadTemplate(threadHandle, range);
+    }
+    disposeCommentThread(owner, threadId) {
+        const controller = this.getCommentController(owner);
+        controller?.deleteCommentThreadMain(threadId);
+    }
+    getCommentMenus(owner) {
+        if (this._commentMenus.get(owner)) {
+            return this._commentMenus.get(owner);
+        }
+        const menu = this.instantiationService.createInstance(CommentMenus);
+        this._commentMenus.set(owner, menu);
+        return menu;
+    }
+    updateComments(ownerId, event) {
+        const control = this._commentControls.get(ownerId);
+        if (control) {
+            const evt = Object.assign({}, event, { owner: ownerId, ownerLabel: control.label });
+            this.updateModelThreads(evt);
+        }
+    }
+    updateNotebookComments(ownerId, event) {
+        const evt = Object.assign({}, event, { owner: ownerId });
+        this._onDidUpdateNotebookCommentThreads.fire(evt);
+    }
+    updateCommentingRanges(ownerId) {
+        this._workspaceHasCommenting.set(true);
+        this._onDidUpdateCommentingRanges.fire({ owner: ownerId });
+    }
+    async toggleReaction(owner, resource, thread, comment, reaction) {
+        const commentController = this._commentControls.get(owner);
+        if (commentController) {
+            return commentController.toggleReaction(resource, thread, comment, reaction, CancellationToken.None);
+        }
+        else {
+            throw new Error('Not supported');
+        }
+    }
+    hasReactionHandler(owner) {
+        const commentProvider = this._commentControls.get(owner);
+        if (commentProvider) {
+            return !!commentProvider.features.reactionHandler;
+        }
+        return false;
+    }
+    async getDocumentComments(resource) {
+        const commentControlResult = [];
+        for (const control of ( this._commentControls.values())) {
+            commentControlResult.push(control.getDocumentComments(resource, CancellationToken.None)
+                .then(documentComments => {
+                for (const documentCommentThread of documentComments.threads) {
+                    if (documentCommentThread.comments?.length === 0 && documentCommentThread.range) {
+                        this.removeContinueOnComment({ range: documentCommentThread.range, uri: resource, owner: documentComments.owner });
+                    }
+                }
+                const pendingComments = this._continueOnComments.get(documentComments.owner);
+                documentComments.pendingCommentThreads = pendingComments?.filter(pendingComment => ( pendingComment.uri.toString()) === ( resource.toString()));
+                return documentComments;
+            })
+                .catch(_ => {
+                return null;
+            }));
+        }
+        return Promise.all(commentControlResult);
+    }
+    async getNotebookComments(resource) {
+        const commentControlResult = [];
+        this._commentControls.forEach(control => {
+            commentControlResult.push(control.getNotebookComments(resource, CancellationToken.None)
+                .catch(_ => {
+                return null;
+            }));
+        });
+        return Promise.all(commentControlResult);
+    }
+    registerContinueOnCommentProvider(provider) {
+        this._continueOnCommentProviders.add(provider);
+        return {
+            dispose: () => {
+                this._continueOnCommentProviders.delete(provider);
+            }
+        };
+    }
+    _saveContinueOnComments(map) {
+        const commentsToSave = [];
+        for (const pendingComments of ( map.values())) {
+            commentsToSave.push(...pendingComments);
+        }
+        this.logService.debug(`Comments: URIs of continue on comments to add to storage ${( commentsToSave.map(thread => ( thread.uri.toString()))).join(', ')}.`);
+        this.storageService.store(CONTINUE_ON_COMMENTS, commentsToSave, 1 , 0 );
+    }
+    removeContinueOnComment(pendingComment) {
+        const pendingComments = this._continueOnComments.get(pendingComment.owner);
+        if (pendingComments) {
+            const commentIndex = pendingComments.findIndex(comment => ( comment.uri.toString()) === ( pendingComment.uri.toString()) && Range.equalsRange(comment.range, pendingComment.range) && (pendingComment.isReply === undefined || comment.isReply === pendingComment.isReply));
+            if (commentIndex > -1) {
+                return pendingComments.splice(commentIndex, 1)[0];
+            }
+        }
+        return undefined;
+    }
+    _addContinueOnComments(pendingComments, map) {
+        const changedOwners = ( new Set());
+        for (const pendingComment of pendingComments) {
+            if (!( map.has(pendingComment.owner))) {
+                map.set(pendingComment.owner, [pendingComment]);
+                changedOwners.add(pendingComment.owner);
+            }
+            else {
+                const commentsForOwner = map.get(pendingComment.owner);
+                if (commentsForOwner.every(comment => (( comment.uri.toString()) !== ( pendingComment.uri.toString())) || !Range.equalsRange(comment.range, pendingComment.range))) {
+                    commentsForOwner.push(pendingComment);
+                    changedOwners.add(pendingComment.owner);
+                }
+            }
+        }
+        return changedOwners;
+    }
+};
+CommentService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkbenchLayoutService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, ILogService))
+], CommentService));
+export { CommentService, ICommentService };