@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/workbench/api/browser/mainThreadEditorTabs.js

@@ -0,0 +1,473 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../common/editor.js';
+import { DiffEditorInput } from '../../common/editor/diffEditorInput.js';
+import { editorGroupToColumn, columnToEditorGroup } from '../../services/editor/common/editorGroupColumn.js';
+import { preferredSideBySideGroupDirection, IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
+import { SIDE_GROUP, IEditorService } from '../../services/editor/common/editorService.js';
+import { AbstractTextResourceEditorInput } from '../../common/editor/textResourceEditorInput.js';
+import { NotebookEditorInput } from '../../../../../override/vs/workbench/contrib/notebook/common/notebookEditorInput.js';
+import { CustomEditorInput } from '../../contrib/customEditor/browser/customEditorInput.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { WebviewInput } from '../../contrib/webviewPanel/browser/webviewEditorInput.js';
+import { TerminalEditorInput } from '../../contrib/terminal/browser/terminalEditorInput.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { SideBySideEditorInput } from '../../common/editor/sideBySideEditorInput.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isGroupEditorMoveEvent } from '../../common/editor/editorGroupModel.js';
+import { InteractiveEditorInput } from '../../contrib/interactive/browser/interactiveEditorInput.js';
+import { MergeEditorInput } from '../../contrib/mergeEditor/browser/mergeEditorInput.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+let MainThreadEditorTabs = class MainThreadEditorTabs {
+    constructor(extHostContext, _editorGroupsService, _configurationService, _logService, editorService) {
+        this._editorGroupsService = _editorGroupsService;
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this._dispoables = ( new DisposableStore());
+        this._tabGroupModel = [];
+        this._groupLookup = ( new Map());
+        this._tabInfoLookup = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostEditorTabs));
+        this._dispoables.add(editorService.onDidEditorsChange((event) => {
+            try {
+                this._updateTabsModel(event);
+            }
+            catch {
+                this._logService.error('Failed to update model, rebuilding');
+                this._createTabsModel();
+            }
+        }));
+        this._dispoables.add(this._editorGroupsService.onDidAddGroup(() => this._createTabsModel()));
+        this._dispoables.add(this._editorGroupsService.onDidRemoveGroup(() => this._createTabsModel()));
+        this._editorGroupsService.whenReady.then(() => this._createTabsModel());
+    }
+    dispose() {
+        this._groupLookup.clear();
+        this._tabInfoLookup.clear();
+        this._dispoables.dispose();
+    }
+    _buildTabObject(group, editor, editorIndex) {
+        const editorId = editor.editorId;
+        const tab = {
+            id: this._generateTabId(editor, group.id),
+            label: editor.getName(),
+            editorId,
+            input: this._editorInputToDto(editor),
+            isPinned: group.isSticky(editorIndex),
+            isPreview: !group.isPinned(editorIndex),
+            isActive: group.isActive(editor),
+            isDirty: editor.isDirty()
+        };
+        return tab;
+    }
+    _editorInputToDto(editor) {
+        if (editor instanceof MergeEditorInput) {
+            return {
+                kind: 3 ,
+                base: editor.base,
+                input1: editor.input1.uri,
+                input2: editor.input2.uri,
+                result: editor.resource
+            };
+        }
+        if (editor instanceof AbstractTextResourceEditorInput) {
+            return {
+                kind: 1 ,
+                uri: editor.resource
+            };
+        }
+        if (editor instanceof SideBySideEditorInput && !(editor instanceof DiffEditorInput)) {
+            const primaryResource = editor.primary.resource;
+            const secondaryResource = editor.secondary.resource;
+            if (editor.primary instanceof AbstractTextResourceEditorInput
+                && editor.secondary instanceof AbstractTextResourceEditorInput
+                && isEqual(primaryResource, secondaryResource)
+                && primaryResource
+                && secondaryResource) {
+                return {
+                    kind: 1 ,
+                    uri: primaryResource
+                };
+            }
+            return { kind: 0  };
+        }
+        if (editor instanceof NotebookEditorInput) {
+            return {
+                kind: 4 ,
+                notebookType: editor.viewType,
+                uri: editor.resource
+            };
+        }
+        if (editor instanceof CustomEditorInput) {
+            return {
+                kind: 6 ,
+                viewType: editor.viewType,
+                uri: editor.resource,
+            };
+        }
+        if (editor instanceof WebviewInput) {
+            return {
+                kind: 7 ,
+                viewType: editor.viewType
+            };
+        }
+        if (editor instanceof TerminalEditorInput) {
+            return {
+                kind: 8
+            };
+        }
+        if (editor instanceof DiffEditorInput) {
+            if (editor.modified instanceof AbstractTextResourceEditorInput && editor.original instanceof AbstractTextResourceEditorInput) {
+                return {
+                    kind: 2 ,
+                    modified: editor.modified.resource,
+                    original: editor.original.resource
+                };
+            }
+            if (editor.modified instanceof NotebookEditorInput && editor.original instanceof NotebookEditorInput) {
+                return {
+                    kind: 5 ,
+                    notebookType: editor.original.viewType,
+                    modified: editor.modified.resource,
+                    original: editor.original.resource
+                };
+            }
+        }
+        if (editor instanceof InteractiveEditorInput) {
+            return {
+                kind: 9 ,
+                uri: editor.resource,
+                inputBoxUri: editor.inputResource
+            };
+        }
+        return { kind: 0  };
+    }
+    _generateTabId(editor, groupId) {
+        let resourceString;
+        const resource = EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.BOTH });
+        if (resource instanceof URI) {
+            resourceString = ( resource.toString());
+        }
+        else {
+            resourceString = `${resource?.primary?.toString()}-${resource?.secondary?.toString()}`;
+        }
+        return `${groupId}~${editor.editorId}-${editor.typeId}-${resourceString} `;
+    }
+    _onDidGroupActivate() {
+        const activeGroupId = this._editorGroupsService.activeGroup.id;
+        const activeGroup = this._groupLookup.get(activeGroupId);
+        if (activeGroup) {
+            activeGroup.isActive = true;
+            this._proxy.$acceptTabGroupUpdate(activeGroup);
+        }
+    }
+    _onDidTabLabelChange(groupId, editorInput, editorIndex) {
+        const tabId = this._generateTabId(editorInput, groupId);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        if (tabInfo) {
+            tabInfo.tab.label = editorInput.getName();
+            this._proxy.$acceptTabOperation({
+                groupId,
+                index: editorIndex,
+                tabDto: tabInfo.tab,
+                kind: 2
+            });
+        }
+        else {
+            this._logService.error('Invalid model for label change, rebuilding');
+            this._createTabsModel();
+        }
+    }
+    _onDidTabOpen(groupId, editorInput, editorIndex) {
+        const group = this._editorGroupsService.getGroup(groupId);
+        const groupInModel = this._groupLookup.get(groupId) !== undefined;
+        if (!group || !groupInModel) {
+            this._createTabsModel();
+            return;
+        }
+        const tabs = this._groupLookup.get(groupId)?.tabs;
+        if (!tabs) {
+            return;
+        }
+        const tabObject = this._buildTabObject(group, editorInput, editorIndex);
+        tabs.splice(editorIndex, 0, tabObject);
+        this._tabInfoLookup.set(this._generateTabId(editorInput, groupId), { group, editorInput, tab: tabObject });
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: tabObject,
+            kind: 0
+        });
+    }
+    _onDidTabClose(groupId, editorIndex) {
+        const group = this._editorGroupsService.getGroup(groupId);
+        const tabs = this._groupLookup.get(groupId)?.tabs;
+        if (!group || !tabs) {
+            this._createTabsModel();
+            return;
+        }
+        const removedTab = tabs.splice(editorIndex, 1);
+        if (removedTab.length === 0) {
+            return;
+        }
+        this._tabInfoLookup.delete(removedTab[0]?.id ?? '');
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: removedTab[0],
+            kind: 1
+        });
+    }
+    _onDidTabActiveChange(groupId, editorIndex) {
+        const tabs = this._groupLookup.get(groupId)?.tabs;
+        if (!tabs) {
+            return;
+        }
+        const activeTab = tabs[editorIndex];
+        activeTab.isActive = true;
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: activeTab,
+            kind: 2
+        });
+    }
+    _onDidTabDirty(groupId, editorIndex, editor) {
+        const tabId = this._generateTabId(editor, groupId);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        if (!tabInfo) {
+            this._logService.error('Invalid model for dirty change, rebuilding');
+            this._createTabsModel();
+            return;
+        }
+        tabInfo.tab.isDirty = editor.isDirty();
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: tabInfo.tab,
+            kind: 2
+        });
+    }
+    _onDidTabPinChange(groupId, editorIndex, editor) {
+        const tabId = this._generateTabId(editor, groupId);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        const group = tabInfo?.group;
+        const tab = tabInfo?.tab;
+        if (!group || !tab) {
+            this._logService.error('Invalid model for sticky change, rebuilding');
+            this._createTabsModel();
+            return;
+        }
+        tab.isPinned = group.isSticky(editorIndex);
+        this._proxy.$acceptTabOperation({
+            groupId,
+            index: editorIndex,
+            tabDto: tab,
+            kind: 2
+        });
+    }
+    _onDidTabPreviewChange(groupId, editorIndex, editor) {
+        const tabId = this._generateTabId(editor, groupId);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        const group = tabInfo?.group;
+        const tab = tabInfo?.tab;
+        if (!group || !tab) {
+            this._logService.error('Invalid model for sticky change, rebuilding');
+            this._createTabsModel();
+            return;
+        }
+        tab.isPreview = !group.isPinned(editorIndex);
+        this._proxy.$acceptTabOperation({
+            kind: 2 ,
+            groupId,
+            tabDto: tab,
+            index: editorIndex
+        });
+    }
+    _onDidTabMove(groupId, editorIndex, oldEditorIndex, editor) {
+        const tabs = this._groupLookup.get(groupId)?.tabs;
+        if (!tabs) {
+            this._logService.error('Invalid model for move change, rebuilding');
+            this._createTabsModel();
+            return;
+        }
+        const removedTab = tabs.splice(oldEditorIndex, 1);
+        if (removedTab.length === 0) {
+            return;
+        }
+        tabs.splice(editorIndex, 0, removedTab[0]);
+        this._proxy.$acceptTabOperation({
+            kind: 3 ,
+            groupId,
+            tabDto: removedTab[0],
+            index: editorIndex,
+            oldIndex: oldEditorIndex
+        });
+    }
+    _createTabsModel() {
+        this._tabGroupModel = [];
+        this._groupLookup.clear();
+        this._tabInfoLookup.clear();
+        let tabs = [];
+        for (const group of this._editorGroupsService.groups) {
+            const currentTabGroupModel = {
+                groupId: group.id,
+                isActive: group.id === this._editorGroupsService.activeGroup.id,
+                viewColumn: editorGroupToColumn(this._editorGroupsService, group),
+                tabs: []
+            };
+            group.editors.forEach((editor, editorIndex) => {
+                const tab = this._buildTabObject(group, editor, editorIndex);
+                tabs.push(tab);
+                this._tabInfoLookup.set(this._generateTabId(editor, group.id), {
+                    group,
+                    tab,
+                    editorInput: editor
+                });
+            });
+            currentTabGroupModel.tabs = tabs;
+            this._tabGroupModel.push(currentTabGroupModel);
+            this._groupLookup.set(group.id, currentTabGroupModel);
+            tabs = [];
+        }
+        this._proxy.$acceptEditorTabModel(this._tabGroupModel);
+    }
+    _updateTabsModel(changeEvent) {
+        const event = changeEvent.event;
+        const groupId = changeEvent.groupId;
+        switch (event.kind) {
+            case 0 :
+                if (groupId === this._editorGroupsService.activeGroup.id) {
+                    this._onDidGroupActivate();
+                    break;
+                }
+                else {
+                    return;
+                }
+            case 7 :
+                if (event.editor !== undefined && event.editorIndex !== undefined) {
+                    this._onDidTabLabelChange(groupId, event.editor, event.editorIndex);
+                    break;
+                }
+            case 3 :
+                if (event.editor !== undefined && event.editorIndex !== undefined) {
+                    this._onDidTabOpen(groupId, event.editor, event.editorIndex);
+                    break;
+                }
+            case 4 :
+                if (event.editorIndex !== undefined) {
+                    this._onDidTabClose(groupId, event.editorIndex);
+                    break;
+                }
+            case 6 :
+                if (event.editorIndex !== undefined) {
+                    this._onDidTabActiveChange(groupId, event.editorIndex);
+                    break;
+                }
+            case 11 :
+                if (event.editorIndex !== undefined && event.editor !== undefined) {
+                    this._onDidTabDirty(groupId, event.editorIndex, event.editor);
+                    break;
+                }
+            case 10 :
+                if (event.editorIndex !== undefined && event.editor !== undefined) {
+                    this._onDidTabPinChange(groupId, event.editorIndex, event.editor);
+                    break;
+                }
+            case 9 :
+                if (event.editorIndex !== undefined && event.editor !== undefined) {
+                    this._onDidTabPreviewChange(groupId, event.editorIndex, event.editor);
+                    break;
+                }
+            case 5 :
+                if (isGroupEditorMoveEvent(event) && event.editor && event.editorIndex !== undefined && event.oldEditorIndex !== undefined) {
+                    this._onDidTabMove(groupId, event.editorIndex, event.oldEditorIndex, event.editor);
+                    break;
+                }
+            default:
+                this._createTabsModel();
+        }
+    }
+    $moveTab(tabId, index, viewColumn, preserveFocus) {
+        const groupId = columnToEditorGroup(this._editorGroupsService, this._configurationService, viewColumn);
+        const tabInfo = this._tabInfoLookup.get(tabId);
+        const tab = tabInfo?.tab;
+        if (!tab) {
+            throw new Error(`Attempted to close tab with id ${tabId} which does not exist`);
+        }
+        let targetGroup;
+        const sourceGroup = this._editorGroupsService.getGroup(tabInfo.group.id);
+        if (!sourceGroup) {
+            return;
+        }
+        if (this._groupLookup.get(groupId) === undefined) {
+            let direction = 3 ;
+            if (viewColumn === SIDE_GROUP) {
+                direction = preferredSideBySideGroupDirection(this._configurationService);
+            }
+            targetGroup = this._editorGroupsService.addGroup(this._editorGroupsService.groups[this._editorGroupsService.groups.length - 1], direction, undefined);
+        }
+        else {
+            targetGroup = this._editorGroupsService.getGroup(groupId);
+        }
+        if (!targetGroup) {
+            return;
+        }
+        if (index < 0 || index > targetGroup.editors.length) {
+            index = targetGroup.editors.length;
+        }
+        const editorInput = tabInfo?.editorInput;
+        if (!editorInput) {
+            return;
+        }
+        sourceGroup.moveEditor(editorInput, targetGroup, { index, preserveFocus });
+        return;
+    }
+    async $closeTab(tabIds, preserveFocus) {
+        const groups = ( new Map());
+        for (const tabId of tabIds) {
+            const tabInfo = this._tabInfoLookup.get(tabId);
+            const tab = tabInfo?.tab;
+            const group = tabInfo?.group;
+            const editorTab = tabInfo?.editorInput;
+            if (!group || !tab || !tabInfo || !editorTab) {
+                continue;
+            }
+            const groupEditors = groups.get(group);
+            if (!groupEditors) {
+                groups.set(group, [editorTab]);
+            }
+            else {
+                groupEditors.push(editorTab);
+            }
+        }
+        const results = [];
+        for (const [group, editors] of groups) {
+            results.push(await group.closeEditors(editors, { preserveFocus }));
+        }
+        return results.every(result => result);
+    }
+    async $closeGroup(groupIds, preserveFocus) {
+        const groupCloseResults = [];
+        for (const groupId of groupIds) {
+            const group = this._editorGroupsService.getGroup(groupId);
+            if (group) {
+                groupCloseResults.push(await group.closeAllEditors());
+                if (group.count === 0 && this._editorGroupsService.getGroup(group.id)) {
+                    this._editorGroupsService.removeGroup(group);
+                }
+            }
+        }
+        return groupCloseResults.every(result => result);
+    }
+};
+MainThreadEditorTabs = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadEditorTabs),
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IEditorService))
+], MainThreadEditorTabs);
+export { MainThreadEditorTabs };

package/dist/vscode/vs/workbench/api/browser/mainThreadLanguageFeatures.js

@@ -13,7 +13,7 @@ import { decodeSemanticTokensDto } from 'monaco-editor/esm/vs/editor/common/serv
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
 import { reviveWorkspaceEditDto } from './mainThreadBulkEdits.js';
 import { DataTransfer } from '../common/extHostTypeConverters.js';
-import { DataTransferCache } from '../common/shared/dataTransferCache.js';
+import { DataTransferFileCache } from '../common/shared/dataTransferCache.js';
 import { CallHierarchyProviderRegistry } from '../../contrib/callHierarchy/common/callHierarchy.js';
 import { WorkspaceSymbolProviderRegistry } from '../../contrib/search/common/search.js';
 import { TypeHierarchyProviderRegistry } from '../../contrib/typeHierarchy/common/typeHierarchy.js';
@@ -291,8 +291,8 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
         }
         this._registrations.set(handle, this._languageFeaturesService.codeActionProvider.register(selector, provider));
     }
-    $registerPasteEditProvider(handle, selector, supportsCopy, pasteMimeTypes) {
-        const provider = ( new MainThreadPasteEditProvider(handle, this._proxy, supportsCopy, pasteMimeTypes, this._uriIdentService));
+    $registerPasteEditProvider(handle, selector, metadata) {
+        const provider = ( new MainThreadPasteEditProvider(handle, this._proxy, metadata, this._uriIdentService));
         this._pasteEditProviders.set(handle, provider);
         this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentPasteEditProvider.register(selector, provider), toDisposable(() => this._pasteEditProviders.delete(handle))));
     }
@@ -742,8 +742,8 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             }
         }));
     }
-    $registerDocumentOnDropEditProvider(handle, selector, extensionId, metadata) {
-        const provider = ( new MainThreadDocumentOnDropEditProvider(handle, extensionId, metadata, this._proxy, this._uriIdentService));
+    $registerDocumentOnDropEditProvider(handle, selector, metadata) {
+        const provider = ( new MainThreadDocumentOnDropEditProvider(handle, metadata, this._proxy, this._uriIdentService));
         this._documentOnDropEditProviders.set(handle, provider);
         this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentOnDropEditProvider.register(selector, provider), toDisposable(() => this._documentOnDropEditProviders.delete(handle))));
     }
@@ -763,74 +763,81 @@ MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = __decorate([
     ( __param(4, IUriIdentityService))
 ], MainThreadLanguageFeatures);
 let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
-    constructor(handle, _proxy, supportsCopy, pasteMimeTypes, _uriIdentService) {
+    constructor(handle, _proxy, metadata, _uriIdentService) {
         this.handle = handle;
         this._proxy = _proxy;
         this._uriIdentService = _uriIdentService;
-        this.dataTransfers = ( new DataTransferCache());
-        this.pasteMimeTypes = pasteMimeTypes;
-        if (supportsCopy) {
+        this.dataTransfers = ( new DataTransferFileCache());
+        this.copyMimeTypes = metadata.copyMimeTypes;
+        this.pasteMimeTypes = metadata.pasteMimeTypes;
+        if (metadata.supportsCopy) {
             this.prepareDocumentPaste = async (model, selections, dataTransfer, token) => {
-                const dataTransferDto = await DataTransfer.toDataTransferDTO(dataTransfer);
+                const dataTransferDto = await DataTransfer.from(dataTransfer);
                 if (token.isCancellationRequested) {
                     return undefined;
                 }
-                const result = await this._proxy.$prepareDocumentPaste(handle, model.uri, selections, dataTransferDto, token);
-                if (!result) {
+                const newDataTransfer = await this._proxy.$prepareDocumentPaste(handle, model.uri, selections, dataTransferDto, token);
+                if (!newDataTransfer) {
                     return undefined;
                 }
                 const dataTransferOut = ( new VSDataTransfer());
-                result.items.forEach(([type, item]) => {
+                for (const [type, item] of newDataTransfer.items) {
                     dataTransferOut.replace(type, createStringDataTransferItem(item.asString));
-                });
+                }
                 return dataTransferOut;
             };
         }
-    }
-    async provideDocumentPasteEdits(model, selections, dataTransfer, token) {
-        const request = this.dataTransfers.add(dataTransfer);
-        try {
-            const d = await DataTransfer.toDataTransferDTO(dataTransfer);
-            const result = await this._proxy.$providePasteEdits(this.handle, request.id, model.uri, selections, d, token);
-            if (!result) {
-                return undefined;
-            }
-            return {
-                insertText: result.insertText,
-                additionalEdit: result.additionalEdit ? reviveWorkspaceEditDto(result.additionalEdit, this._uriIdentService, dataId => this.resolveFileData(request.id, dataId)) : undefined,
+        if (metadata.supportsPaste) {
+            this.provideDocumentPasteEdits = async (model, selections, dataTransfer, token) => {
+                const request = this.dataTransfers.add(dataTransfer);
+                try {
+                    const dataTransferDto = await DataTransfer.from(dataTransfer);
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                    const result = await this._proxy.$providePasteEdits(this.handle, request.id, model.uri, selections, dataTransferDto, token);
+                    if (!result) {
+                        return;
+                    }
+                    return {
+                        ...result,
+                        additionalEdit: result.additionalEdit ? reviveWorkspaceEditDto(result.additionalEdit, this._uriIdentService, dataId => this.resolveFileData(request.id, dataId)) : undefined,
+                    };
+                }
+                finally {
+                    request.dispose();
+                }
             };
         }
-        finally {
-            request.dispose();
-        }
     }
     resolveFileData(requestId, dataId) {
         return this.dataTransfers.resolveFileData(requestId, dataId);
     }
 };
 MainThreadPasteEditProvider = ( __decorate([
-    ( __param(4, IUriIdentityService))
+    ( __param(3, IUriIdentityService))
 ], MainThreadPasteEditProvider));
 let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditProvider {
-    constructor(handle, extensionId, metadata, _proxy, _uriIdentService) {
+    constructor(handle, metadata, _proxy, _uriIdentService) {
         this.handle = handle;
         this._proxy = _proxy;
         this._uriIdentService = _uriIdentService;
-        this.dataTransfers = ( new DataTransferCache());
-        this.id = extensionId.value + (metadata ? '.' + metadata.id : '');
+        this.dataTransfers = ( new DataTransferFileCache());
         this.dropMimeTypes = metadata?.dropMimeTypes ?? ['*/*'];
     }
     async provideDocumentOnDropEdits(model, position, dataTransfer, token) {
         const request = this.dataTransfers.add(dataTransfer);
         try {
-            const dataTransferDto = await DataTransfer.toDataTransferDTO(dataTransfer);
+            const dataTransferDto = await DataTransfer.from(dataTransfer);
+            if (token.isCancellationRequested) {
+                return;
+            }
             const edit = await this._proxy.$provideDocumentOnDropEdits(this.handle, request.id, model.uri, position, dataTransferDto, token);
             if (!edit) {
-                return undefined;
+                return;
             }
             return {
-                label: edit.label,
-                insertText: edit.insertText,
+                ...edit,
                 additionalEdit: reviveWorkspaceEditDto(edit.additionalEdit, this._uriIdentService, dataId => this.resolveDocumentOnDropFileData(request.id, dataId)),
             };
         }
@@ -843,7 +850,7 @@ let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditPro
     }
 };
 MainThreadDocumentOnDropEditProvider = ( __decorate([
-    ( __param(4, IUriIdentityService))
+    ( __param(3, IUriIdentityService))
 ], MainThreadDocumentOnDropEditProvider));
 class MainThreadDocumentSemanticTokensProvider {
     constructor(_proxy, _handle, _legend, onDidChange) {