@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,127 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { hashAsync } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { EditorModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorModel';
+
+function parseUnifiedDiff(diffText) {
+    const lines = diffText.split('\n');
+    const beforeLines = [];
+    const afterLines = [];
+    for (const line of lines) {
+        if (line.startsWith('- ')) {
+            beforeLines.push(line.substring(2));
+        }
+        else if (line.startsWith('-')) {
+            beforeLines.push(line.substring(1));
+        }
+        else if (line.startsWith('+ ')) {
+            afterLines.push(line.substring(2));
+        }
+        else if (line.startsWith('+')) {
+            afterLines.push(line.substring(1));
+        }
+        else if (line.startsWith(' ')) {
+            const content = line.substring(1);
+            beforeLines.push(content);
+            afterLines.push(content);
+        }
+        else if (!line.startsWith('@@') && !line.startsWith('---') && !line.startsWith('+++') && !line.startsWith('diff ')) {
+            beforeLines.push(line);
+            afterLines.push(line);
+        }
+    }
+    return {
+        before: beforeLines.join('\n'),
+        after: afterLines.join('\n')
+    };
+}
+class SimpleDiffEditorModel extends EditorModel {
+    constructor(_original, _modified) {
+        super();
+        this._original = _original;
+        this._modified = _modified;
+        this.original = this._original.object.textEditorModel;
+        this.modified = this._modified.object.textEditorModel;
+    }
+    dispose() {
+        super.dispose();
+        this._original.dispose();
+        this._modified.dispose();
+    }
+}
+let MarkdownDiffBlockPart = class MarkdownDiffBlockPart extends Disposable {
+    constructor(data, diffEditorPool, currentWidth, modelService, textModelService, languageService) {
+        super();
+        this.modelService = modelService;
+        this.textModelService = textModelService;
+        this.languageService = languageService;
+        this._onDidChangeContentHeight = this._register(( new Emitter()));
+        this.onDidChangeContentHeight = this._onDidChangeContentHeight.event;
+        this.modelRef = this._register(( new MutableDisposable()));
+        this.comparePart = this._register(diffEditorPool.get());
+        this._register(this.comparePart.object.onDidChangeContentHeight(() => {
+            this._onDidChangeContentHeight.fire();
+        }));
+        const originalUri = ( URI.from({
+            scheme: Schemas.vscodeChatCodeBlock,
+            path: `/chat-diff-original-${data.codeBlockIndex}-${generateUuid()}`,
+        }));
+        const modifiedUri = ( URI.from({
+            scheme: Schemas.vscodeChatCodeBlock,
+            path: `/chat-diff-modified-${data.codeBlockIndex}-${generateUuid()}`,
+        }));
+        const languageSelection = this.languageService.createById(data.languageId);
+        this._register(this.modelService.createModel(data.beforeContent, languageSelection, originalUri, false));
+        this._register(this.modelService.createModel(data.afterContent, languageSelection, modifiedUri, false));
+        const modelsPromise = Promise.all([
+            this.textModelService.createModelReference(originalUri),
+            this.textModelService.createModelReference(modifiedUri)
+        ]).then(([originalRef, modifiedRef]) => {
+            return ( new SimpleDiffEditorModel(originalRef, modifiedRef));
+        });
+        const compareData = {
+            element: data.element,
+            isReadOnly: data.isReadOnly,
+            horizontalPadding: data.horizontalPadding,
+            edit: {
+                uri: data.codeBlockResource || modifiedUri,
+                edits: [],
+                kind: 'textEditGroup',
+                done: true
+            },
+            diffData: modelsPromise.then(async (model) => {
+                this.modelRef.value = model;
+                const diffData = {
+                    original: model.original,
+                    modified: model.modified,
+                    originalSha1: await hashAsync(model.original.getValue()),
+                };
+                return diffData;
+            })
+        };
+        this.comparePart.object.render(compareData, currentWidth, CancellationToken.None);
+        this.element = this.comparePart.object.element;
+    }
+    layout(width) {
+        this.comparePart.object.layout(width);
+    }
+    reset() {
+        this.modelRef.clear();
+    }
+};
+MarkdownDiffBlockPart = ( __decorate([
+    ( __param(3, IModelService)),
+    ( __param(4, ITextModelService)),
+    ( __param(5, ILanguageService))
+], MarkdownDiffBlockPart));
+
+export { MarkdownDiffBlockPart, parseUnifiedDiff };

package/vscode/src/vs/workbench/contrib/chat/browser/chatDragAndDrop.d.ts

@@ -0,0 +1,43 @@
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { Themable } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { ISharedWebContentExtractorService } from "@codingame/monaco-vscode-api/vscode/vs/platform/webContentExtractor/common/webContentExtractor.service";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { ChatAttachmentModel } from "./chatAttachmentModel.js";
+import { IChatAttachmentResolveService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatAttachmentResolveService.service";
+import { IChatInputStyles } from "./chatInputPart.js";
+export declare class ChatDragAndDrop extends Themable {
+    private readonly widgetRef;
+    private readonly attachmentModel;
+    private readonly styles;
+    private readonly extensionService;
+    private readonly webContentExtractorService;
+    private readonly logService;
+    private readonly chatAttachmentResolveService;
+    private readonly overlays;
+    private overlayText?;
+    private overlayTextBackground;
+    private disableOverlay;
+    constructor(widgetRef: () => IChatWidget | undefined, attachmentModel: ChatAttachmentModel, styles: IChatInputStyles, themeService: IThemeService, extensionService: IExtensionService, webContentExtractorService: ISharedWebContentExtractorService, logService: ILogService, chatAttachmentResolveService: IChatAttachmentResolveService);
+    addOverlay(target: HTMLElement, overlayContainer: HTMLElement): void;
+    removeOverlay(target: HTMLElement): void;
+    setDisabledOverlay(disable: boolean): void;
+    private currentActiveTarget;
+    private createOverlay;
+    private onDragEnter;
+    private onDragLeave;
+    private onDrop;
+    private drop;
+    private updateDropFeedback;
+    private guessDropType;
+    private isDragEventSupported;
+    private getDropTypeName;
+    private resolveAttachmentsFromDragEvent;
+    private downloadImageAsUint8Array;
+    private resolveHTMLAttachContext;
+    private setOverlay;
+    private getOverlayText;
+    private updateOverlayStyles;
+    updateStyles(): void;
+}

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

@@ -0,0 +1,388 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DataTransfers } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dnd';
+import { createElement, DragAndDropObserver, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderLabelWithIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { UriList } from '@codingame/monaco-vscode-api/vscode/vs/base/common/dataTransfer';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Mimes } from '@codingame/monaco-vscode-api/vscode/vs/base/common/mime';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { containsDragType, CodeDataTransfers, extractNotebookCellOutputDropData, extractMarkerDropData, extractSymbolDropData, extractEditorsDropData } from '@codingame/monaco-vscode-api/vscode/vs/platform/dnd/browser/dnd';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { Themable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { ISharedWebContentExtractorService } from '@codingame/monaco-vscode-api/vscode/vs/platform/webContentExtractor/common/webContentExtractor.service';
+import { isProposedApiEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { extractSCMHistoryItemDropData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/browser/scmHistoryChatContext';
+import { IChatAttachmentResolveService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatAttachmentResolveService.service';
+import { convertStringToUInt8Array } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/imageUtils';
+
+var ChatDragAndDropType;
+(function (ChatDragAndDropType) {
+    ChatDragAndDropType[ChatDragAndDropType["FILE_INTERNAL"] = 0] = "FILE_INTERNAL";
+    ChatDragAndDropType[ChatDragAndDropType["FILE_EXTERNAL"] = 1] = "FILE_EXTERNAL";
+    ChatDragAndDropType[ChatDragAndDropType["FOLDER"] = 2] = "FOLDER";
+    ChatDragAndDropType[ChatDragAndDropType["IMAGE"] = 3] = "IMAGE";
+    ChatDragAndDropType[ChatDragAndDropType["SYMBOL"] = 4] = "SYMBOL";
+    ChatDragAndDropType[ChatDragAndDropType["HTML"] = 5] = "HTML";
+    ChatDragAndDropType[ChatDragAndDropType["MARKER"] = 6] = "MARKER";
+    ChatDragAndDropType[ChatDragAndDropType["NOTEBOOK_CELL_OUTPUT"] = 7] = "NOTEBOOK_CELL_OUTPUT";
+    ChatDragAndDropType[ChatDragAndDropType["SCM_HISTORY_ITEM"] = 8] = "SCM_HISTORY_ITEM";
+})(ChatDragAndDropType || (ChatDragAndDropType = {}));
+const IMAGE_DATA_REGEX = /^data:image\/[a-z]+;base64,/;
+const URL_REGEX = /^https?:\/\/.+/;
+let ChatDragAndDrop = class ChatDragAndDrop extends Themable {
+    constructor(widgetRef, attachmentModel, styles, themeService, extensionService, webContentExtractorService, logService, chatAttachmentResolveService) {
+        super(themeService);
+        this.widgetRef = widgetRef;
+        this.attachmentModel = attachmentModel;
+        this.styles = styles;
+        this.extensionService = extensionService;
+        this.webContentExtractorService = webContentExtractorService;
+        this.logService = logService;
+        this.chatAttachmentResolveService = chatAttachmentResolveService;
+        this.overlays = ( new Map());
+        this.overlayTextBackground = '';
+        this.disableOverlay = false;
+        this.currentActiveTarget = undefined;
+        this.updateStyles();
+        this._register(toDisposable(() => {
+            this.overlays.forEach(({ overlay, disposable }) => {
+                disposable.dispose();
+                overlay.remove();
+            });
+            this.overlays.clear();
+            this.currentActiveTarget = undefined;
+            this.overlayText?.remove();
+            this.overlayText = undefined;
+        }));
+    }
+    addOverlay(target, overlayContainer) {
+        this.removeOverlay(target);
+        const { overlay, disposable } = this.createOverlay(target, overlayContainer);
+        this.overlays.set(target, { overlay, disposable });
+    }
+    removeOverlay(target) {
+        if (this.currentActiveTarget === target) {
+            this.currentActiveTarget = undefined;
+        }
+        const existingOverlay = this.overlays.get(target);
+        if (existingOverlay) {
+            existingOverlay.overlay.remove();
+            existingOverlay.disposable.dispose();
+            this.overlays.delete(target);
+        }
+    }
+    setDisabledOverlay(disable) {
+        this.disableOverlay = disable;
+    }
+    createOverlay(target, overlayContainer) {
+        const overlay = createElement('div');
+        overlay.classList.add('chat-dnd-overlay');
+        this.updateOverlayStyles(overlay);
+        overlayContainer.appendChild(overlay);
+        const disposable = ( new DragAndDropObserver(target, {
+            onDragOver: (e) => {
+                if (this.disableOverlay) {
+                    return;
+                }
+                e.stopPropagation();
+                e.preventDefault();
+                if (target === this.currentActiveTarget) {
+                    return;
+                }
+                if (this.currentActiveTarget) {
+                    this.setOverlay(this.currentActiveTarget, undefined);
+                }
+                this.currentActiveTarget = target;
+                this.onDragEnter(e, target);
+            },
+            onDragLeave: (e) => {
+                if (this.disableOverlay) {
+                    return;
+                }
+                if (target === this.currentActiveTarget) {
+                    this.currentActiveTarget = undefined;
+                }
+                this.onDragLeave(e, target);
+            },
+            onDrop: (e) => {
+                if (this.disableOverlay) {
+                    return;
+                }
+                e.stopPropagation();
+                e.preventDefault();
+                if (target !== this.currentActiveTarget) {
+                    return;
+                }
+                this.currentActiveTarget = undefined;
+                this.onDrop(e, target);
+            },
+        }));
+        return { overlay, disposable };
+    }
+    onDragEnter(e, target) {
+        const estimatedDropType = this.guessDropType(e);
+        this.updateDropFeedback(e, target, estimatedDropType);
+    }
+    onDragLeave(e, target) {
+        this.updateDropFeedback(e, target, undefined);
+    }
+    onDrop(e, target) {
+        this.updateDropFeedback(e, target, undefined);
+        this.drop(e);
+    }
+    async drop(e) {
+        const contexts = await this.resolveAttachmentsFromDragEvent(e);
+        if (contexts.length === 0) {
+            return;
+        }
+        this.attachmentModel.addContext(...contexts);
+    }
+    updateDropFeedback(e, target, dropType) {
+        const showOverlay = dropType !== undefined;
+        if (e.dataTransfer) {
+            e.dataTransfer.dropEffect = showOverlay ? 'copy' : 'none';
+        }
+        this.setOverlay(target, dropType);
+    }
+    guessDropType(e) {
+        if (containsDragType(e, CodeDataTransfers.NOTEBOOK_CELL_OUTPUT)) {
+            return ChatDragAndDropType.NOTEBOOK_CELL_OUTPUT;
+        }
+        else if (containsDragType(e, CodeDataTransfers.SCM_HISTORY_ITEM)) {
+            return ChatDragAndDropType.SCM_HISTORY_ITEM;
+        }
+        else if (containsImageDragType(e)) {
+            return ( this.extensionService.extensions.some(ext => isProposedApiEnabled(ext, 'chatReferenceBinaryData'))) ? ChatDragAndDropType.IMAGE : undefined;
+        }
+        else if (containsDragType(e, 'text/html')) {
+            return ChatDragAndDropType.HTML;
+        }
+        else if (containsDragType(e, CodeDataTransfers.SYMBOLS)) {
+            return ChatDragAndDropType.SYMBOL;
+        }
+        else if (containsDragType(e, CodeDataTransfers.MARKERS)) {
+            return ChatDragAndDropType.MARKER;
+        }
+        else if (containsDragType(e, DataTransfers.FILES)) {
+            return ChatDragAndDropType.FILE_EXTERNAL;
+        }
+        else if (containsDragType(e, CodeDataTransfers.EDITORS)) {
+            return ChatDragAndDropType.FILE_INTERNAL;
+        }
+        else if (containsDragType(e, Mimes.uriList, CodeDataTransfers.FILES, DataTransfers.RESOURCES, DataTransfers.INTERNAL_URI_LIST)) {
+            return ChatDragAndDropType.FOLDER;
+        }
+        return undefined;
+    }
+    isDragEventSupported(e) {
+        const dropType = this.guessDropType(e);
+        return dropType !== undefined;
+    }
+    getDropTypeName(type) {
+        switch (type) {
+            case ChatDragAndDropType.FILE_INTERNAL: return localize(5176, 'File');
+            case ChatDragAndDropType.FILE_EXTERNAL: return localize(5176, 'File');
+            case ChatDragAndDropType.FOLDER: return localize(5177, 'Folder');
+            case ChatDragAndDropType.IMAGE: return localize(5178, 'Image');
+            case ChatDragAndDropType.SYMBOL: return localize(5179, 'Symbol');
+            case ChatDragAndDropType.MARKER: return localize(5180, 'Problem');
+            case ChatDragAndDropType.HTML: return localize(5181, 'URL');
+            case ChatDragAndDropType.NOTEBOOK_CELL_OUTPUT: return localize(5182, 'Output');
+            case ChatDragAndDropType.SCM_HISTORY_ITEM: return localize(5183, 'Change');
+        }
+    }
+    async resolveAttachmentsFromDragEvent(e) {
+        if (!this.isDragEventSupported(e)) {
+            return [];
+        }
+        if (containsDragType(e, CodeDataTransfers.NOTEBOOK_CELL_OUTPUT)) {
+            const notebookOutputData = extractNotebookCellOutputDropData(e);
+            if (notebookOutputData) {
+                return this.chatAttachmentResolveService.resolveNotebookOutputAttachContext(notebookOutputData);
+            }
+        }
+        if (containsDragType(e, CodeDataTransfers.SCM_HISTORY_ITEM)) {
+            const scmHistoryItemData = extractSCMHistoryItemDropData(e);
+            if (scmHistoryItemData) {
+                return this.chatAttachmentResolveService.resolveSourceControlHistoryItemAttachContext(scmHistoryItemData);
+            }
+        }
+        const markerData = extractMarkerDropData(e);
+        if (markerData) {
+            return this.chatAttachmentResolveService.resolveMarkerAttachContext(markerData);
+        }
+        if (containsDragType(e, CodeDataTransfers.SYMBOLS)) {
+            const symbolsData = extractSymbolDropData(e);
+            return this.chatAttachmentResolveService.resolveSymbolsAttachContext(symbolsData);
+        }
+        const editorDragData = extractEditorsDropData(e);
+        if (editorDragData.length > 0) {
+            return coalesce(await Promise.all(( editorDragData.map(editorInput => {
+                return this.chatAttachmentResolveService.resolveEditorAttachContext(editorInput);
+            }))));
+        }
+        const internal = e.dataTransfer?.getData(DataTransfers.INTERNAL_URI_LIST);
+        if (internal) {
+            const uriList = UriList.parse(internal);
+            if (uriList.length) {
+                return coalesce(await Promise.all(( uriList.map(
+                    uri => this.chatAttachmentResolveService.resolveEditorAttachContext({ resource: ( URI.parse(uri)) })
+                ))));
+            }
+        }
+        if (!containsDragType(e, DataTransfers.INTERNAL_URI_LIST) && containsDragType(e, Mimes.uriList) && (((containsDragType(e, Mimes.html) || containsDragType(e, Mimes.text)) ))) {
+            return this.resolveHTMLAttachContext(e);
+        }
+        return [];
+    }
+    async downloadImageAsUint8Array(url) {
+        try {
+            const extractedImages = await this.webContentExtractorService.readImage(( URI.parse(url)), CancellationToken.None);
+            if (extractedImages) {
+                return extractedImages.buffer;
+            }
+        }
+        catch (error) {
+            this.logService.warn('Fetch failed:', error);
+        }
+        const widget = this.widgetRef();
+        const selection = widget?.inputEditor.getSelection();
+        if (selection && widget) {
+            widget.inputEditor.executeEdits('chatInsertUrl', [{ range: selection, text: url }]);
+        }
+        this.logService.warn(`Image URLs must end in .jpg, .png, .gif, .webp, or .bmp. Failed to fetch image from this URL: ${url}`);
+        return undefined;
+    }
+    async resolveHTMLAttachContext(e) {
+        const existingAttachmentNames = ( new Set(( this.attachmentModel.attachments.map(attachment => attachment.name))));
+        const createDisplayName = () => {
+            const baseName = ( localize(5184, 'Image from URL'));
+            let uniqueName = baseName;
+            let baseNameInstance = 1;
+            while (( existingAttachmentNames.has(uniqueName))) {
+                uniqueName = `${baseName} ${++baseNameInstance}`;
+            }
+            existingAttachmentNames.add(uniqueName);
+            return uniqueName;
+        };
+        const getImageTransferDataFromUrl = async (url) => {
+            const resource = ( URI.parse(url));
+            if (IMAGE_DATA_REGEX.test(url)) {
+                return { data: convertStringToUInt8Array(url), name: createDisplayName(), resource };
+            }
+            if (URL_REGEX.test(url)) {
+                const data = await this.downloadImageAsUint8Array(url);
+                if (data) {
+                    return { data, name: createDisplayName(), resource, id: url };
+                }
+            }
+            return undefined;
+        };
+        const getImageTransferDataFromFile = async (file) => {
+            try {
+                const buffer = await file.arrayBuffer();
+                return { data: ( new Uint8Array(buffer)), name: createDisplayName() };
+            }
+            catch (error) {
+                this.logService.error('Error reading file:', error);
+            }
+            return undefined;
+        };
+        const imageTransferData = [];
+        const imageFiles = extractImageFilesFromDragEvent(e);
+        if (imageFiles.length) {
+            const imageTransferDataFromFiles = await Promise.all(( imageFiles.map(file => getImageTransferDataFromFile(file))));
+            imageTransferData.push(...imageTransferDataFromFiles.filter(data => !!data));
+        }
+        const imageUrls = extractUrlsFromDragEvent(e);
+        if (imageUrls.length) {
+            const imageTransferDataFromUrl = await Promise.all(( imageUrls.map(getImageTransferDataFromUrl)));
+            imageTransferData.push(...imageTransferDataFromUrl.filter(data => !!data));
+        }
+        return await this.chatAttachmentResolveService.resolveImageAttachContext(imageTransferData);
+    }
+    setOverlay(target, type) {
+        this.overlayText?.remove();
+        this.overlayText = undefined;
+        const { overlay } = this.overlays.get(target);
+        if (type !== undefined) {
+            const iconAndtextElements = renderLabelWithIcons(`$(${Codicon.attach.id}) ${this.getOverlayText(type)}`);
+            const htmlElements = ( iconAndtextElements.map(element => {
+                if (typeof element === 'string') {
+                    return $('span.overlay-text', undefined, element);
+                }
+                return element;
+            }));
+            this.overlayText = $('span.attach-context-overlay-text', undefined, ...htmlElements);
+            this.overlayText.style.backgroundColor = this.overlayTextBackground;
+            overlay.appendChild(this.overlayText);
+        }
+        overlay.classList.toggle('visible', type !== undefined);
+    }
+    getOverlayText(type) {
+        const typeName = this.getDropTypeName(type);
+        return localize(5185, 'Attach {0} as Context', typeName);
+    }
+    updateOverlayStyles(overlay) {
+        overlay.style.backgroundColor = this.getColor(this.styles.overlayBackground) || '';
+        overlay.style.color = this.getColor(this.styles.listForeground) || '';
+    }
+    updateStyles() {
+        this.overlays.forEach(overlay => this.updateOverlayStyles(overlay.overlay));
+        this.overlayTextBackground = this.getColor(this.styles.listBackground) || '';
+    }
+};
+ChatDragAndDrop = ( __decorate([
+    ( __param(3, IThemeService)),
+    ( __param(4, IExtensionService)),
+    ( __param(5, ISharedWebContentExtractorService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IChatAttachmentResolveService))
+], ChatDragAndDrop));
+function containsImageDragType(e) {
+    if (containsDragType(e, 'image')) {
+        return true;
+    }
+    if (containsDragType(e, DataTransfers.FILES)) {
+        const files = e.dataTransfer?.files;
+        if (files && files.length > 0) {
+            return ( Array.from(files).some(file => file.type.startsWith('image/')));
+        }
+        const items = e.dataTransfer?.items;
+        if (items && items.length > 0) {
+            return ( Array.from(items).some(item => item.type.startsWith('image/')));
+        }
+    }
+    return false;
+}
+function extractUrlsFromDragEvent(e, logService) {
+    const textUrl = e.dataTransfer?.getData('text/uri-list');
+    if (textUrl) {
+        try {
+            const urls = UriList.parse(textUrl);
+            if (urls.length > 0) {
+                return urls;
+            }
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    return [];
+}
+function extractImageFilesFromDragEvent(e) {
+    const files = e.dataTransfer?.files;
+    if (!files) {
+        return [];
+    }
+    return Array.from(files).filter(file => file.type.startsWith('image/'));
+}
+
+export { ChatDragAndDrop };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingActions.d.ts

@@ -0,0 +1,49 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions";
+import { Action2, IAction2Options } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IChatEditingSession } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+export declare abstract class EditingSessionAction extends Action2 {
+    constructor(opts: Readonly<IAction2Options>);
+    run(accessor: ServicesAccessor, ...args: unknown[]): any;
+    abstract runEditingSessionAction(accessor: ServicesAccessor, editingSession: IChatEditingSession, chatWidget: IChatWidget, ...args: unknown[]): any;
+}
+/**
+ * Resolve view title toolbar context. If none, return context from the lastFocusedWidget.
+ */
+export declare function getEditingSessionContext(accessor: ServicesAccessor, args: any[]): {
+    editingSession?: IChatEditingSession;
+    chatWidget: IChatWidget;
+} | undefined;
+export declare class ChatEditingAcceptAllAction extends EditingSessionAction {
+    constructor();
+    runEditingSessionAction(accessor: ServicesAccessor, editingSession: IChatEditingSession, chatWidget: IChatWidget, ...args: unknown[]): Promise<void>;
+}
+export declare class ChatEditingDiscardAllAction extends EditingSessionAction {
+    constructor();
+    runEditingSessionAction(accessor: ServicesAccessor, editingSession: IChatEditingSession, chatWidget: IChatWidget, ...args: unknown[]): Promise<void>;
+}
+export declare function discardAllEditsWithConfirmation(accessor: ServicesAccessor, currentEditingSession: IChatEditingSession): Promise<boolean>;
+export declare class ChatEditingShowChangesAction extends EditingSessionAction {
+    static readonly ID = "chatEditing.viewChanges";
+    static readonly LABEL: string;
+    constructor();
+    runEditingSessionAction(accessor: ServicesAccessor, editingSession: IChatEditingSession, chatWidget: IChatWidget, ...args: unknown[]): Promise<void>;
+}
+export declare class ViewAllSessionChangesAction extends Action2 {
+    static readonly ID = "chatEditing.viewAllSessionChanges";
+    constructor();
+    run(accessor: ServicesAccessor, sessionResource?: URI): Promise<void>;
+}
+export interface ChatEditingActionContext {
+    readonly sessionResource: URI;
+    readonly requestId: string;
+    readonly uri: URI;
+    readonly stopId: string | undefined;
+}
+export declare class ViewPreviousEditsAction extends EditingSessionAction {
+    static readonly Id = "chatEditing.viewPreviousEdits";
+    static readonly Label: string;
+    constructor();
+    runEditingSessionAction(accessor: ServicesAccessor, editingSession: IChatEditingSession, chatWidget: IChatWidget, ...args: unknown[]): Promise<void>;
+}