@codingame/monaco-vscode-api 1.85.0 → 1.85.1

package/vscode/src/vs/workbench/contrib/chat/browser/chatMarkdownDecorationsRenderer.js

@@ -0,0 +1,115 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ChatRequestTextPart } from '../common/chatParserTypes.js';
+const variableRefUrl = 'http://_vscodedecoration_';
+function convertParsedRequestToMarkdown(parsedRequest) {
+    let result = '';
+    for (const part of parsedRequest.parts) {
+        if (part instanceof ChatRequestTextPart) {
+            result += part.text;
+        }
+        else {
+            result += `[${part.text}](${variableRefUrl})`;
+        }
+    }
+    return result;
+}
+function walkTreeAndAnnotateReferenceLinks(element) {
+    element.querySelectorAll('a').forEach(a => {
+        const href = a.getAttribute('data-href');
+        if (href) {
+            if (href.startsWith(variableRefUrl)) {
+                a.parentElement.replaceChild(renderResourceWidget(a.textContent), a);
+            }
+            else if (href.startsWith(contentRefUrl)) {
+                renderFileWidget(href, a);
+            }
+        }
+    });
+}
+function renderResourceWidget(name) {
+    const container = dom.$('span.chat-resource-widget');
+    const alias = dom.$('span', undefined, name);
+    container.appendChild(alias);
+    return container;
+}
+function renderFileWidget(href, a) {
+    const fullUri = ( URI.parse(href));
+    const location = revive(JSON.parse(fullUri.fragment));
+    const fragment = location.range ? `${location.range.startLineNumber}-${location.range.endLineNumber}` : '';
+    a.setAttribute('data-href', ( location.uri.with({ fragment }).toString()));
+}
+function extractVulnerabilitiesFromText(text) {
+    const vulnerabilities = [];
+    let newText = text;
+    let match;
+    while ((match = /<vscode_annotation details="(.*?)">(.*?)<\/vscode_annotation>/ms.exec(newText)) !== null) {
+        const [full, details, content] = match;
+        const start = match.index;
+        const textBefore = newText.substring(0, start);
+        const linesBefore = textBefore.split('\n').length - 1;
+        const linesInside = content.split('\n').length - 1;
+        const previousNewlineIdx = textBefore.lastIndexOf('\n');
+        const startColumn = start - (previousNewlineIdx + 1) + 1;
+        const endPreviousNewlineIdx = (textBefore + content).lastIndexOf('\n');
+        const endColumn = start + content.length - (endPreviousNewlineIdx + 1) + 1;
+        try {
+            const vulnDetails = JSON.parse(decodeURIComponent(details));
+            vulnDetails.forEach(({ title, description }) => vulnerabilities.push({
+                title, description, range: { startLineNumber: linesBefore + 1, startColumn, endLineNumber: linesBefore + linesInside + 1, endColumn }
+            }));
+        }
+        catch (err) {
+        }
+        newText = newText.substring(0, start) + content + newText.substring(start + full.length);
+    }
+    return { newText, vulnerabilities };
+}
+const contentRefUrl = 'http://_vscodecontentref_';
+function annotateSpecialMarkdownContent(response) {
+    const result = [];
+    for (const item of response) {
+        const previousItem = result[result.length - 1];
+        if (item.kind === 'inlineReference') {
+            const location = 'uri' in item.inlineReference ? item.inlineReference : { uri: item.inlineReference };
+            const printUri = ( URI.parse(contentRefUrl)).with({ fragment: JSON.stringify(location) });
+            const markdownText = `[${item.name || basename(location.uri)}](${( printUri.toString())})`;
+            if (previousItem?.kind === 'markdownContent') {
+                result[result.length - 1] = { content: ( new MarkdownString(
+                    previousItem.content.value + markdownText,
+                    { isTrusted: previousItem.content.isTrusted }
+                )), kind: 'markdownContent' };
+            }
+            else {
+                result.push({ content: ( new MarkdownString(markdownText)), kind: 'markdownContent' });
+            }
+        }
+        else if (item.kind === 'markdownContent' && previousItem?.kind === 'markdownContent') {
+            result[result.length - 1] = { content: ( new MarkdownString(
+                previousItem.content.value + item.content.value,
+                { isTrusted: previousItem.content.isTrusted }
+            )), kind: 'markdownContent' };
+        }
+        else if (item.kind === 'markdownVuln') {
+            const vulnText = encodeURIComponent(JSON.stringify(item.vulnerabilities));
+            const markdownText = `<vscode_annotation details="${vulnText}">${item.content.value}</vscode_annotation>`;
+            if (previousItem?.kind === 'markdownContent') {
+                result[result.length - 1] = { content: ( new MarkdownString(
+                    previousItem.content.value + markdownText,
+                    { isTrusted: previousItem.content.isTrusted }
+                )), kind: 'markdownContent' };
+            }
+            else {
+                result.push({ content: ( new MarkdownString(markdownText)), kind: 'markdownContent' });
+            }
+        }
+        else {
+            result.push(item);
+        }
+    }
+    return result;
+}
+export { annotateSpecialMarkdownContent, convertParsedRequestToMarkdown, extractVulnerabilitiesFromText, walkTreeAndAnnotateReferenceLinks };

package/vscode/src/vs/workbench/contrib/chat/browser/chatOptions.js

@@ -0,0 +1,81 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+var ChatEditorOptions_1;
+let ChatEditorOptions = class ChatEditorOptions extends Disposable {
+    static { ChatEditorOptions_1 = this; }
+    static { this.lineHeightEm = 1.4; }
+    get configuration() {
+        return this._config;
+    }
+    static { this.relevantSettingIds = [
+        'chat.editor.lineHeight',
+        'chat.editor.fontSize',
+        'chat.editor.fontFamily',
+        'chat.editor.fontWeight',
+        'chat.editor.wordWrap',
+        'editor.cursorBlinking',
+        'editor.fontLigatures',
+        'editor.accessibilitySupport',
+        'editor.bracketPairColorization.enabled',
+        'editor.bracketPairColorization.independentColorPoolPerBracketType',
+    ]; }
+    constructor(viewId, foreground, inputEditorBackgroundColor, resultEditorBackgroundColor, configurationService, themeService, viewDescriptorService) {
+        super();
+        this.foreground = foreground;
+        this.inputEditorBackgroundColor = inputEditorBackgroundColor;
+        this.resultEditorBackgroundColor = resultEditorBackgroundColor;
+        this.configurationService = configurationService;
+        this.themeService = themeService;
+        this.viewDescriptorService = viewDescriptorService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(this.themeService.onDidColorThemeChange(e => this.update()));
+        this._register(this.viewDescriptorService.onDidChangeLocation(e => {
+            if (( e.views.some(v => v.id === viewId))) {
+                this.update();
+            }
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (( ChatEditorOptions_1.relevantSettingIds.some(id => e.affectsConfiguration(id)))) {
+                this.update();
+            }
+        }));
+        this.update();
+    }
+    update() {
+        const editorConfig = this.configurationService.getValue('editor');
+        const chatEditorConfig = this.configurationService.getValue('chat')?.editor;
+        const accessibilitySupport = this.configurationService.getValue('editor.accessibilitySupport');
+        this._config = {
+            foreground: this.themeService.getColorTheme().getColor(this.foreground),
+            inputEditor: {
+                backgroundColor: this.themeService.getColorTheme().getColor(this.inputEditorBackgroundColor),
+                accessibilitySupport,
+            },
+            resultEditor: {
+                backgroundColor: this.themeService.getColorTheme().getColor(this.resultEditorBackgroundColor),
+                fontSize: chatEditorConfig.fontSize,
+                fontFamily: chatEditorConfig.fontFamily === 'default' ? editorConfig.fontFamily : chatEditorConfig.fontFamily,
+                fontWeight: chatEditorConfig.fontWeight,
+                lineHeight: chatEditorConfig.lineHeight ? chatEditorConfig.lineHeight : ChatEditorOptions_1.lineHeightEm * chatEditorConfig.fontSize,
+                bracketPairColorization: {
+                    enabled: this.configurationService.getValue('editor.bracketPairColorization.enabled'),
+                    independentColorPoolPerBracketType: this.configurationService.getValue('editor.bracketPairColorization.independentColorPoolPerBracketType'),
+                },
+                wordWrap: chatEditorConfig.wordWrap,
+                fontLigatures: editorConfig.fontLigatures,
+            }
+        };
+        this._onDidChange.fire();
+    }
+};
+ChatEditorOptions = ChatEditorOptions_1 = ( __decorate([
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IViewDescriptorService))
+], ChatEditorOptions));
+export { ChatEditorOptions };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSlashCommandContentWidget.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".chat-slash-command-content-widget{background-color:var(--vscode-chat-slashCommandBackground);border-radius:3px;color:var(--vscode-chat-slashCommandForeground);padding:1px}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSlashCommandContentWidget.js

@@ -0,0 +1,62 @@
+import './chatSlashCommandContentWidget.css.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import * as aria from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+class SlashCommandContentWidget extends Disposable {
+    constructor(_editor) {
+        super();
+        this._editor = _editor;
+        this._domNode = document.createElement('div');
+        this._isVisible = false;
+        this._domNode.toggleAttribute('hidden', true);
+        this._domNode.classList.add('chat-slash-command-content-widget');
+        this._register(this._editor.onKeyDown((e) => this._handleKeyDown(e)));
+    }
+    dispose() {
+        this._editor.removeContentWidget(this);
+        super.dispose();
+    }
+    show() {
+        if (this._isVisible) {
+            return;
+        }
+        this._isVisible = true;
+        this._domNode.toggleAttribute('hidden', false);
+        this._editor.addContentWidget(this);
+    }
+    hide() {
+        this._isVisible = false;
+        this._domNode.toggleAttribute('hidden', true);
+        this._editor.removeContentWidget(this);
+    }
+    setCommandText(slashCommand) {
+        this._domNode.innerText = `/${slashCommand} `;
+        this._lastSlashCommandText = slashCommand;
+    }
+    getId() { return 'chat-slash-command-content-widget'; }
+    getDomNode() { return this._domNode; }
+    getPosition() { return { position: { lineNumber: 1, column: 1 }, preference: [0 ] }; }
+    _handleKeyDown(e) {
+        if (e.keyCode !== 1 ) {
+            return;
+        }
+        const firstLine = this._editor.getModel()?.getLineContent(1);
+        const selection = this._editor.getSelection();
+        const withSlash = `/${this._lastSlashCommandText} `;
+        if (!firstLine?.startsWith(withSlash) || !selection?.isEmpty() || selection?.startLineNumber !== 1 || selection?.startColumn !== withSlash.length + 1) {
+            return;
+        }
+        this._editor.executeEdits('chat-slash-command', [{
+                range: ( new Range(1, 1, 1, selection.startColumn)),
+                text: null
+            }]);
+        aria.alert(( localizeWithPath(
+            'vs/workbench/contrib/chat/browser/chatSlashCommandContentWidget',
+            'exited slash command mode',
+            'Exited {0} mode',
+            this._lastSlashCommandText
+        )));
+    }
+}
+export { SlashCommandContentWidget };