@codingame/monaco-vscode-extensions-service-override 1.83.8 → 1.83.9

package/{dist/main/vscode → vscode}/src/vs/workbench/api/common/extHostWorkspace.d.ts

@@ -1,6 +1,6 @@
 import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { CancellationToken as CancellationToken$1 } from 'vscode/vscode/vs/base/common/cancellation';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { URI, UriComponents } from 'vscode/vscode/vs/base/common/uri';
 import { IExtensionDescription, ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
@@ -12,20 +12,19 @@ import { IExtHostInitDataService } from './extHostInitDataService.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { IURITransformerService } from './extHostUriTransformerService.js';
 import { IRawFileMatch2 } from 'vscode/vscode/vs/workbench/services/search/common/search';
-import { TextSearchQuery, FindTextInFilesOptions, TextSearchResult, TextSearchComplete, WorkspaceTrustRequestOptions, EditSessionIdentityProvider, EditSessionIdentityWillCreateEvent, CanonicalUriProvider, CanonicalUriRequestOptions } from '../../../../../../../../vscode-proposed.js';
+import * as vscode from 'vscode';
 import { ExtHostWorkspaceShape, IWorkspaceData } from './extHost.protocol.js';
-import { WorkspaceFoldersChangeEvent, Uri, WorkspaceFolder, GlobPattern, CancellationToken } from 'vscode';
 
 interface IExtHostWorkspaceProvider {
-    getWorkspaceFolder2(uri: Uri, resolveParent?: boolean): Promise<WorkspaceFolder | undefined>;
-    resolveWorkspaceFolder(uri: Uri): Promise<WorkspaceFolder | undefined>;
-    getWorkspaceFolders2(): Promise<WorkspaceFolder[] | undefined>;
+    getWorkspaceFolder2(uri: vscode.Uri, resolveParent?: boolean): Promise<vscode.WorkspaceFolder | undefined>;
+    resolveWorkspaceFolder(uri: vscode.Uri): Promise<vscode.WorkspaceFolder | undefined>;
+    getWorkspaceFolders2(): Promise<vscode.WorkspaceFolder[] | undefined>;
     resolveProxy(url: string): Promise<string | undefined>;
 }
 declare class ExtHostWorkspace implements ExtHostWorkspaceShape, IExtHostWorkspaceProvider {
     readonly _serviceBrand: undefined;
     private readonly _onDidChangeWorkspace;
-    readonly onDidChangeWorkspace: Event<WorkspaceFoldersChangeEvent>;
+    readonly onDidChangeWorkspace: Event<vscode.WorkspaceFoldersChangeEvent>;
     private readonly _onDidGrantWorkspaceTrust;
     readonly onDidGrantWorkspaceTrust: Event<void>;
     private readonly _logService;
@@ -45,45 +44,45 @@ declare class ExtHostWorkspace implements ExtHostWorkspaceShape, IExtHostWorkspa
     waitForInitializeCall(): Promise<boolean>;
     get workspace(): Workspace | undefined;
     get name(): string | undefined;
-    get workspaceFile(): Uri | undefined;
+    get workspaceFile(): vscode.Uri | undefined;
     private get _actualWorkspace();
-    getWorkspaceFolders(): WorkspaceFolder[] | undefined;
-    getWorkspaceFolders2(): Promise<WorkspaceFolder[] | undefined>;
+    getWorkspaceFolders(): vscode.WorkspaceFolder[] | undefined;
+    getWorkspaceFolders2(): Promise<vscode.WorkspaceFolder[] | undefined>;
     updateWorkspaceFolders(extension: IExtensionDescription, index: number, deleteCount: number, ...workspaceFoldersToAdd: {
-        uri: Uri;
+        uri: vscode.Uri;
         name?: string;
     }[]): boolean;
-    getWorkspaceFolder(uri: Uri, resolveParent?: boolean): WorkspaceFolder | undefined;
-    getWorkspaceFolder2(uri: Uri, resolveParent?: boolean): Promise<WorkspaceFolder | undefined>;
-    resolveWorkspaceFolder(uri: Uri): Promise<WorkspaceFolder | undefined>;
+    getWorkspaceFolder(uri: vscode.Uri, resolveParent?: boolean): vscode.WorkspaceFolder | undefined;
+    getWorkspaceFolder2(uri: vscode.Uri, resolveParent?: boolean): Promise<vscode.WorkspaceFolder | undefined>;
+    resolveWorkspaceFolder(uri: vscode.Uri): Promise<vscode.WorkspaceFolder | undefined>;
     getPath(): string | undefined;
-    getRelativePath(pathOrUri: string | Uri, includeWorkspace?: boolean): string;
+    getRelativePath(pathOrUri: string | vscode.Uri, includeWorkspace?: boolean): string;
     private trySetWorkspaceFolders;
     $acceptWorkspaceData(data: IWorkspaceData | null): void;
     /**
      * Note, null/undefined have different and important meanings for "exclude"
      */
-    findFiles(include: GlobPattern | undefined, exclude: GlobPattern | null | undefined, maxResults: number | undefined, extensionId: ExtensionIdentifier, token?: CancellationToken): Promise<Uri[]>;
-    findTextInFiles(query: TextSearchQuery, options: FindTextInFilesOptions, callback: (result: TextSearchResult) => void, extensionId: ExtensionIdentifier, token?: CancellationToken): Promise<TextSearchComplete>;
+    findFiles(include: vscode.GlobPattern | undefined, exclude: vscode.GlobPattern | null | undefined, maxResults: number | undefined, extensionId: ExtensionIdentifier, token?: vscode.CancellationToken): Promise<vscode.Uri[]>;
+    findTextInFiles(query: vscode.TextSearchQuery, options: vscode.FindTextInFilesOptions, callback: (result: vscode.TextSearchResult) => void, extensionId: ExtensionIdentifier, token?: vscode.CancellationToken): Promise<vscode.TextSearchComplete>;
     $handleTextSearchResult(result: IRawFileMatch2, requestId: number): void;
     save(uri: URI): Promise<URI | undefined>;
     saveAs(uri: URI): Promise<URI | undefined>;
     saveAll(includeUntitled?: boolean): Promise<boolean>;
     resolveProxy(url: string): Promise<string | undefined>;
     get trusted(): boolean;
-    requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
+    requestWorkspaceTrust(options?: vscode.WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
     $onDidGrantWorkspaceTrust(): void;
     private _providerHandlePool;
-    registerEditSessionIdentityProvider(scheme: string, provider: EditSessionIdentityProvider): IDisposable;
-    $getEditSessionIdentifier(workspaceFolder: UriComponents, cancellationToken: CancellationToken$1): Promise<string | undefined>;
-    $provideEditSessionIdentityMatch(workspaceFolder: UriComponents, identity1: string, identity2: string, cancellationToken: CancellationToken$1): Promise<EditSessionIdentityMatch | undefined>;
+    registerEditSessionIdentityProvider(scheme: string, provider: vscode.EditSessionIdentityProvider): IDisposable;
+    $getEditSessionIdentifier(workspaceFolder: UriComponents, cancellationToken: CancellationToken): Promise<string | undefined>;
+    $provideEditSessionIdentityMatch(workspaceFolder: UriComponents, identity1: string, identity2: string, cancellationToken: CancellationToken): Promise<EditSessionIdentityMatch | undefined>;
     private readonly _onWillCreateEditSessionIdentityEvent;
-    getOnWillCreateEditSessionIdentityEvent(extension: IExtensionDescription): Event<EditSessionIdentityWillCreateEvent>;
-    $onWillCreateEditSessionIdentity(workspaceFolder: UriComponents, token: CancellationToken$1, timeout: number): Promise<void>;
+    getOnWillCreateEditSessionIdentityEvent(extension: IExtensionDescription): Event<vscode.EditSessionIdentityWillCreateEvent>;
+    $onWillCreateEditSessionIdentity(workspaceFolder: UriComponents, token: CancellationToken, timeout: number): Promise<void>;
     private readonly _canonicalUriProviders;
-    registerCanonicalUriProvider(scheme: string, provider: CanonicalUriProvider): IDisposable;
-    provideCanonicalUri(uri: URI, options: CanonicalUriRequestOptions, cancellationToken: CancellationToken$1): Promise<URI | undefined>;
-    $provideCanonicalUri(uri: UriComponents, targetScheme: string, cancellationToken: CancellationToken$1): Promise<UriComponents | undefined>;
+    registerCanonicalUriProvider(scheme: string, provider: vscode.CanonicalUriProvider): IDisposable;
+    provideCanonicalUri(uri: URI, options: vscode.CanonicalUriRequestOptions, cancellationToken: CancellationToken): Promise<URI | undefined>;
+    $provideCanonicalUri(uri: UriComponents, targetScheme: string, cancellationToken: CancellationToken): Promise<UriComponents | undefined>;
 }
 declare const IExtHostWorkspace: ServiceIdentifier<IExtHostWorkspace>;
 interface IExtHostWorkspace extends ExtHostWorkspace, ExtHostWorkspaceShape, IExtHostWorkspaceProvider {

package/vscode/src/vs/workbench/api/common/shared/dataTransferCache.js

@@ -0,0 +1,35 @@
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+
+class DataTransferFileCache {
+    constructor() {
+        this.requestIdPool = 0;
+        this.dataTransferFiles = ( new Map());
+    }
+    add(dataTransfer) {
+        const requestId = this.requestIdPool++;
+        this.dataTransferFiles.set(requestId, coalesce(Array.from(dataTransfer, ([, item]) => item.asFile())));
+        return {
+            id: requestId,
+            dispose: () => {
+                this.dataTransferFiles.delete(requestId);
+            }
+        };
+    }
+    async resolveFileData(requestId, dataItemId) {
+        const files = this.dataTransferFiles.get(requestId);
+        if (!files) {
+            throw new Error('No data transfer found');
+        }
+        const file = files.find(file => file.id === dataItemId);
+        if (!file) {
+            throw new Error('No matching file found in data transfer');
+        }
+        return VSBuffer.wrap(await file.data());
+    }
+    dispose() {
+        this.dataTransferFiles.clear();
+    }
+}
+
+export { DataTransferFileCache };

package/vscode/src/vs/workbench/contrib/chat/common/chatModel.js

@@ -0,0 +1,217 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { isMarkdownString, MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+
+class ChatRequestModel {
+    static { this.nextId = 0; }
+    get id() {
+        return this._id;
+    }
+    get providerRequestId() {
+        return this._providerRequestId;
+    }
+    get username() {
+        return this.session.requesterUsername;
+    }
+    get avatarIconUri() {
+        return this.session.requesterAvatarIconUri;
+    }
+    constructor(session, message, _providerRequestId) {
+        this.session = session;
+        this.message = message;
+        this._providerRequestId = _providerRequestId;
+        this._id = 'request_' + ChatRequestModel.nextId++;
+    }
+    setProviderRequestId(providerRequestId) {
+        this._providerRequestId = providerRequestId;
+    }
+}
+class Response {
+    get onDidChangeValue() {
+        return this._onDidChangeValue.event;
+    }
+    get usedContext() {
+        return this._usedContext;
+    }
+    get value() {
+        return this._responseData;
+    }
+    constructor(value) {
+        this._onDidChangeValue = ( new Emitter());
+        this._responseData = Array.isArray(value) ? value : [value];
+        this._responseParts = Array.isArray(value) ? ( value.map((v) => ('value' in v ? { string: v } : { treeData: v }))) : [{ string: value }];
+        this._responseRepr = ( this._responseParts.map((part) => {
+            if (isCompleteInteractiveProgressTreeData(part)) {
+                return '';
+            }
+            return part.string.value;
+        })).join('\n');
+    }
+    asString() {
+        return this._responseRepr;
+    }
+    updateContent(responsePart, quiet) {
+        if (typeof responsePart === 'string' || isMarkdownString(responsePart)) {
+            const responsePartLength = this._responseParts.length - 1;
+            const lastResponsePart = this._responseParts[responsePartLength];
+            if (lastResponsePart.isPlaceholder === true || isCompleteInteractiveProgressTreeData(lastResponsePart)) {
+                this._responseParts.push({ string: typeof responsePart === 'string' ? ( new MarkdownString(responsePart)) : responsePart });
+            }
+            else {
+                if (isMarkdownString(responsePart)) {
+                    this._responseParts[responsePartLength] = { string: ( new MarkdownString(lastResponsePart.string.value + responsePart.value, responsePart)) };
+                }
+                else {
+                    this._responseParts[responsePartLength] = { string: ( new MarkdownString(lastResponsePart.string.value + responsePart, lastResponsePart.string)) };
+                }
+            }
+            this._updateRepr(quiet);
+        }
+        else if ('placeholder' in responsePart) {
+            const responsePosition = this._responseParts.push({ string: ( new MarkdownString(responsePart.placeholder)), isPlaceholder: true }) - 1;
+            this._updateRepr(quiet);
+            responsePart.resolvedContent?.then((content) => {
+                if (typeof content === 'string') {
+                    this._responseParts[responsePosition] = { string: ( new MarkdownString(content)), isPlaceholder: true };
+                    this._updateRepr(quiet);
+                }
+                else if ('value' in content) {
+                    this._responseParts[responsePosition] = { string: content, isPlaceholder: true };
+                    this._updateRepr(quiet);
+                }
+                else if (content.treeData) {
+                    this._responseParts[responsePosition] = { treeData: content.treeData };
+                    this._updateRepr(quiet);
+                }
+            });
+        }
+        else if (isCompleteInteractiveProgressTreeData(responsePart)) {
+            this._responseParts.push(responsePart);
+            this._updateRepr(quiet);
+        }
+        else if ('documents' in responsePart) {
+            this._usedContext = responsePart;
+        }
+    }
+    _updateRepr(quiet) {
+        this._responseData = ( this._responseParts.map(part => {
+            if (isCompleteInteractiveProgressTreeData(part)) {
+                return part.treeData;
+            }
+            else if (part.isPlaceholder) {
+                return { ...part.string, isPlaceholder: true };
+            }
+            return part.string;
+        }));
+        this._responseRepr = ( this._responseParts.map(part => {
+            if (isCompleteInteractiveProgressTreeData(part)) {
+                return '';
+            }
+            return part.string.value;
+        })).join('\n\n');
+        if (!quiet) {
+            this._onDidChangeValue.fire();
+        }
+    }
+}
+class ChatResponseModel extends Disposable {
+    static { this.nextId = 0; }
+    get id() {
+        return this._id;
+    }
+    get providerResponseId() {
+        return this._providerResponseId;
+    }
+    get isComplete() {
+        return this._isComplete;
+    }
+    get isCanceled() {
+        return this._isCanceled;
+    }
+    get vote() {
+        return this._vote;
+    }
+    get followups() {
+        return this._followups;
+    }
+    get response() {
+        return this._response;
+    }
+    get errorDetails() {
+        return this._errorDetails;
+    }
+    get providerId() {
+        return this.session.providerId;
+    }
+    get username() {
+        return this.agent?.metadata.fullName ?? this.session.responderUsername;
+    }
+    get avatarIconUri() {
+        return this.agent?.metadata.icon ?? this.session.responderAvatarIconUri;
+    }
+    constructor(_response, session, agent, _isComplete = false, _isCanceled = false, _vote, _providerResponseId, _errorDetails, _followups) {
+        super();
+        this.session = session;
+        this.agent = agent;
+        this._isComplete = _isComplete;
+        this._isCanceled = _isCanceled;
+        this._vote = _vote;
+        this._providerResponseId = _providerResponseId;
+        this._errorDetails = _errorDetails;
+        this._followups = _followups;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._response = ( new Response(_response));
+        this._register(this._response.onDidChangeValue(() => this._onDidChange.fire()));
+        this._id = 'response_' + ChatResponseModel.nextId++;
+    }
+    updateContent(responsePart, quiet) {
+        this._response.updateContent(responsePart, quiet);
+    }
+    setProviderResponseId(providerResponseId) {
+        this._providerResponseId = providerResponseId;
+    }
+    setErrorDetails(errorDetails) {
+        this._errorDetails = errorDetails;
+        this._onDidChange.fire();
+    }
+    complete() {
+        this._isComplete = true;
+        this._onDidChange.fire();
+    }
+    cancel() {
+        this._isComplete = true;
+        this._isCanceled = true;
+        this._onDidChange.fire();
+    }
+    setFollowups(followups) {
+        this._followups = followups;
+        this._onDidChange.fire();
+    }
+    setVote(vote) {
+        this._vote = vote;
+        this._onDidChange.fire();
+    }
+}
+class ChatWelcomeMessageModel {
+    static { this.nextId = 0; }
+    get id() {
+        return this._id;
+    }
+    constructor(session, content) {
+        this.session = session;
+        this.content = content;
+        this._id = 'welcome_' + ChatWelcomeMessageModel.nextId++;
+    }
+    get username() {
+        return this.session.responderUsername;
+    }
+    get avatarIconUri() {
+        return this.session.responderAvatarIconUri;
+    }
+}
+function isCompleteInteractiveProgressTreeData(item) {
+    return typeof item === 'object' && !!item && 'treeData' in item;
+}
+
+export { ChatRequestModel, ChatResponseModel, ChatWelcomeMessageModel, Response, isCompleteInteractiveProgressTreeData };

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

@@ -0,0 +1,57 @@
+import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { registerColor, disabledForeground, contrastBorder, listFocusOutline, transparent } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+
+const resolvedCommentViewIcon = registerColor('commentsView.resolvedIcon', { dark: disabledForeground, light: disabledForeground, hcDark: contrastBorder, hcLight: contrastBorder }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'resolvedCommentIcon',
+    'Icon color for resolved comments.'
+)));
+const unresolvedCommentViewIcon = registerColor('commentsView.unresolvedIcon', { dark: listFocusOutline, light: listFocusOutline, hcDark: contrastBorder, hcLight: contrastBorder }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'unresolvedCommentIcon',
+    'Icon color for unresolved comments.'
+)));
+const resolvedCommentBorder = registerColor('editorCommentsWidget.resolvedBorder', { dark: resolvedCommentViewIcon, light: resolvedCommentViewIcon, hcDark: contrastBorder, hcLight: contrastBorder }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'resolvedCommentBorder',
+    'Color of borders and arrow for resolved comments.'
+)));
+const unresolvedCommentBorder = registerColor('editorCommentsWidget.unresolvedBorder', { dark: unresolvedCommentViewIcon, light: unresolvedCommentViewIcon, hcDark: contrastBorder, hcLight: contrastBorder }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'unresolvedCommentBorder',
+    'Color of borders and arrow for unresolved comments.'
+)));
+registerColor('editorCommentsWidget.rangeBackground', { dark: ( transparent(unresolvedCommentBorder, .1)), light: ( transparent(unresolvedCommentBorder, .1)), hcDark: ( transparent(unresolvedCommentBorder, .1)), hcLight: ( transparent(unresolvedCommentBorder, .1)) }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'commentThreadRangeBackground',
+    'Color of background for comment ranges.'
+)));
+registerColor('editorCommentsWidget.rangeActiveBackground', { dark: ( transparent(unresolvedCommentBorder, .1)), light: ( transparent(unresolvedCommentBorder, .1)), hcDark: ( transparent(unresolvedCommentBorder, .1)), hcLight: ( transparent(unresolvedCommentBorder, .1)) }, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentColors',
+    'commentThreadActiveRangeBackground',
+    'Color of background for currently selected or hovered comment range.'
+)));
+const commentThreadStateBorderColors = ( new Map([
+    [languages.CommentThreadState.Unresolved, unresolvedCommentBorder],
+    [languages.CommentThreadState.Resolved, resolvedCommentBorder],
+]));
+const commentThreadStateIconColors = ( new Map([
+    [languages.CommentThreadState.Unresolved, unresolvedCommentViewIcon],
+    [languages.CommentThreadState.Resolved, resolvedCommentViewIcon],
+]));
+const commentThreadStateColorVar = '--comment-thread-state-color';
+const commentViewThreadStateColorVar = '--comment-view-thread-state-color';
+const commentThreadStateBackgroundColorVar = '--comment-thread-state-background-color';
+function getCommentThreadStateColor(state, theme, map) {
+    const colorId = (state !== undefined) ? map.get(state) : undefined;
+    return (colorId !== undefined) ? theme.getColor(colorId) : undefined;
+}
+function getCommentThreadStateBorderColor(state, theme) {
+    return getCommentThreadStateColor(state, theme, commentThreadStateBorderColors);
+}
+function getCommentThreadStateIconColor(state, theme) {
+    return getCommentThreadStateColor(state, theme, commentThreadStateIconColors);
+}
+
+export { commentThreadStateBackgroundColorVar, commentThreadStateColorVar, commentViewThreadStateColorVar, getCommentThreadStateBorderColor, getCommentThreadStateIconColor };

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

@@ -0,0 +1,51 @@
+import { Button } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { defaultButtonStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+
+class CommentFormActions {
+    constructor(container, actionHandler, maxActions) {
+        this.container = container;
+        this.actionHandler = actionHandler;
+        this.maxActions = maxActions;
+        this._buttonElements = [];
+        this._toDispose = ( new DisposableStore());
+        this._actions = [];
+    }
+    setActions(menu, hasOnlySecondaryActions = false) {
+        this._toDispose.clear();
+        this._buttonElements.forEach(b => b.remove());
+        this._buttonElements = [];
+        const groups = menu.getActions({ shouldForwardArgs: true });
+        let isPrimary = !hasOnlySecondaryActions;
+        for (const group of groups) {
+            const [, actions] = group;
+            this._actions = actions;
+            for (const action of actions) {
+                const button = ( new Button(this.container, { secondary: !isPrimary, ...defaultButtonStyles }));
+                isPrimary = false;
+                this._buttonElements.push(button.element);
+                this._toDispose.add(button);
+                this._toDispose.add(button.onDidClick(() => this.actionHandler(action)));
+                button.enabled = action.enabled;
+                button.label = action.label;
+                if ((this.maxActions !== undefined) && (this._buttonElements.length >= this.maxActions)) {
+                    console.warn(`An extension has contributed more than the allowable number of actions to a comments menu.`);
+                    return;
+                }
+            }
+        }
+    }
+    triggerDefaultAction() {
+        if (this._actions.length) {
+            const lastAction = this._actions[0];
+            if (lastAction.enabled) {
+                return this.actionHandler(lastAction);
+            }
+        }
+    }
+    dispose() {
+        this._toDispose.dispose();
+    }
+}
+
+export { CommentFormActions };

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

@@ -0,0 +1,92 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { OverviewRulerLane } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { registerColor, opaque, listInactiveSelectionBackground, editorBackground, darken, editorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { themeColorFromId } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { CommentThreadState } from 'monaco-editor/esm/vs/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 }, ( nls.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 }, ( nls.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 }, ( nls.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 }, ( nls.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 }, ( nls.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 };