@codingame/monaco-vscode-api 1.78.8 → 1.79.0

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

@@ -0,0 +1,69 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IExtensionStorageService } from '../../../platform/extensionManagement/common/extensionStorage.js';
+import { migrateExtensionStorage } from '../../services/extensions/common/extensionStorageMigration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+let MainThreadStorage = class MainThreadStorage {
+    constructor(extHostContext, _extensionStorageService, _storageService, _instantiationService, _logService) {
+        this._extensionStorageService = _extensionStorageService;
+        this._storageService = _storageService;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._sharedStorageKeysToWatch = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostStorage));
+        this._storageListener = this._storageService.onDidChangeValue(e => {
+            const shared = e.scope === 0 ;
+            if (shared && ( this._sharedStorageKeysToWatch.has(e.key))) {
+                const rawState = this._extensionStorageService.getExtensionStateRaw(e.key, shared);
+                if (typeof rawState === 'string') {
+                    this._proxy.$acceptValue(shared, e.key, rawState);
+                }
+            }
+        });
+    }
+    dispose() {
+        this._storageListener.dispose();
+    }
+    async $initializeExtensionStorage(shared, extensionId) {
+        await this.checkAndMigrateExtensionStorage(extensionId, shared);
+        if (shared) {
+            this._sharedStorageKeysToWatch.set(extensionId, true);
+        }
+        return this._extensionStorageService.getExtensionStateRaw(extensionId, shared);
+    }
+    async $setValue(shared, key, value) {
+        this._extensionStorageService.setExtensionState(key, value, shared);
+    }
+    $registerExtensionStorageKeysToSync(extension, keys) {
+        this._extensionStorageService.setKeysForSync(extension, keys);
+    }
+    async checkAndMigrateExtensionStorage(extensionId, shared) {
+        try {
+            let sourceExtensionId = this._extensionStorageService.getSourceExtensionToMigrate(extensionId);
+            if (!sourceExtensionId && isWeb && extensionId !== extensionId.toLowerCase()) {
+                sourceExtensionId = extensionId.toLowerCase();
+            }
+            if (sourceExtensionId) {
+                if (isWeb && sourceExtensionId !== sourceExtensionId.toLowerCase() && this._extensionStorageService.getExtensionState(sourceExtensionId.toLowerCase(), shared) && !this._extensionStorageService.getExtensionState(sourceExtensionId, shared)) {
+                    sourceExtensionId = sourceExtensionId.toLowerCase();
+                }
+                await migrateExtensionStorage(sourceExtensionId, extensionId, shared, this._instantiationService);
+            }
+        }
+        catch (error) {
+            this._logService.error(error);
+        }
+    }
+};
+MainThreadStorage = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadStorage),
+    ( __param(1, IExtensionStorageService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ILogService))
+], MainThreadStorage);
+export { MainThreadStorage };

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

@@ -0,0 +1,300 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { Extensions, IViewsService, NoTreeViewError, ResolvableTreeItem } from '../../common/views.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { isUndefinedOrNull, isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IExtensionService } from '../../services/extensions/common/extensions.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { createStringDataTransferItem, VSDataTransfer } from 'monaco-editor/esm/vs/base/common/dataTransfer.js';
+import { DataTransferCache } from '../common/shared/dataTransferCache.js';
+import { DataTransfer } from '../common/extHostTypeConverters.js';
+let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
+    constructor(extHostContext, viewsService, notificationService, extensionService, logService) {
+        super();
+        this.viewsService = viewsService;
+        this.notificationService = notificationService;
+        this.extensionService = extensionService;
+        this.logService = logService;
+        this._dataProviders = ( new Map());
+        this._dndControllers = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTreeViews));
+    }
+    async $registerTreeViewDataProvider(treeViewId, options) {
+        this.logService.trace('MainThreadTreeViews#$registerTreeViewDataProvider', treeViewId, options);
+        this.extensionService.whenInstalledExtensionsRegistered().then(() => {
+            const dataProvider = ( new TreeViewDataProvider(treeViewId, this._proxy, this.notificationService));
+            this._dataProviders.set(treeViewId, dataProvider);
+            const dndController = (options.hasHandleDrag || options.hasHandleDrop)
+                ? ( new TreeViewDragAndDropController(
+                treeViewId,
+                options.dropMimeTypes,
+                options.dragMimeTypes,
+                options.hasHandleDrag,
+                this._proxy
+            )) : undefined;
+            const viewer = this.getTreeView(treeViewId);
+            if (viewer) {
+                viewer.showCollapseAllAction = !!options.showCollapseAll;
+                viewer.canSelectMany = !!options.canSelectMany;
+                viewer.dragAndDropController = dndController;
+                if (dndController) {
+                    this._dndControllers.set(treeViewId, dndController);
+                }
+                viewer.dataProvider = dataProvider;
+                this.registerListeners(treeViewId, viewer);
+                this._proxy.$setVisible(treeViewId, viewer.visible);
+            }
+            else {
+                this.notificationService.error('No view is registered with id: ' + treeViewId);
+            }
+        });
+    }
+    $reveal(treeViewId, itemInfo, options) {
+        this.logService.trace('MainThreadTreeViews#$reveal', treeViewId, itemInfo?.item, itemInfo?.parentChain, options);
+        return this.viewsService.openView(treeViewId, options.focus)
+            .then(() => {
+            const viewer = this.getTreeView(treeViewId);
+            if (viewer && itemInfo) {
+                return this.reveal(viewer, this._dataProviders.get(treeViewId), itemInfo.item, itemInfo.parentChain, options);
+            }
+            return undefined;
+        });
+    }
+    $refresh(treeViewId, itemsToRefreshByHandle) {
+        this.logService.trace('MainThreadTreeViews#$refresh', treeViewId, itemsToRefreshByHandle);
+        const viewer = this.getTreeView(treeViewId);
+        const dataProvider = this._dataProviders.get(treeViewId);
+        if (viewer && dataProvider) {
+            const itemsToRefresh = dataProvider.getItemsToRefresh(itemsToRefreshByHandle);
+            return viewer.refresh(itemsToRefresh.length ? itemsToRefresh : undefined);
+        }
+        return Promise.resolve();
+    }
+    $setMessage(treeViewId, message) {
+        this.logService.trace('MainThreadTreeViews#$setMessage', treeViewId, message);
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.message = message;
+        }
+    }
+    $setTitle(treeViewId, title, description) {
+        this.logService.trace('MainThreadTreeViews#$setTitle', treeViewId, title, description);
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.title = title;
+            viewer.description = description;
+        }
+    }
+    $setBadge(treeViewId, badge) {
+        this.logService.trace('MainThreadTreeViews#$setBadge', treeViewId, badge?.value, badge?.tooltip);
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.badge = badge;
+        }
+    }
+    $resolveDropFileData(destinationViewId, requestId, dataItemId) {
+        const controller = this._dndControllers.get(destinationViewId);
+        if (!controller) {
+            throw new Error('Unknown tree');
+        }
+        return controller.resolveDropFileData(requestId, dataItemId);
+    }
+    async $disposeTree(treeViewId) {
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.dataProvider = undefined;
+        }
+    }
+    async reveal(treeView, dataProvider, itemIn, parentChain, options) {
+        options = options ? options : { select: false, focus: false };
+        const select = isUndefinedOrNull(options.select) ? false : options.select;
+        const focus = isUndefinedOrNull(options.focus) ? false : options.focus;
+        let expand = Math.min(isNumber(options.expand) ? options.expand : options.expand === true ? 1 : 0, 3);
+        if (dataProvider.isEmpty()) {
+            await treeView.refresh();
+        }
+        for (const parent of parentChain) {
+            const parentItem = dataProvider.getItem(parent.handle);
+            if (parentItem) {
+                await treeView.expand(parentItem);
+            }
+        }
+        const item = dataProvider.getItem(itemIn.handle);
+        if (item) {
+            await treeView.reveal(item);
+            if (select) {
+                treeView.setSelection([item]);
+            }
+            if (focus === false) {
+                treeView.setFocus();
+            }
+            else if (focus) {
+                treeView.setFocus(item);
+            }
+            let itemsToExpand = [item];
+            for (; itemsToExpand.length > 0 && expand > 0; expand--) {
+                await treeView.expand(itemsToExpand);
+                itemsToExpand = itemsToExpand.reduce((result, itemValue) => {
+                    const item = dataProvider.getItem(itemValue.handle);
+                    if (item && item.children && item.children.length) {
+                        result.push(...item.children);
+                    }
+                    return result;
+                }, []);
+            }
+        }
+    }
+    registerListeners(treeViewId, treeView) {
+        this._register(treeView.onDidExpandItem(item => this._proxy.$setExpanded(treeViewId, item.handle, true)));
+        this._register(treeView.onDidCollapseItem(item => this._proxy.$setExpanded(treeViewId, item.handle, false)));
+        this._register(treeView.onDidChangeSelection(items => this._proxy.$setSelection(treeViewId, ( items.map(({ handle }) => handle)))));
+        this._register(treeView.onDidChangeFocus(item => this._proxy.$setFocus(treeViewId, item.handle)));
+        this._register(treeView.onDidChangeVisibility(isVisible => this._proxy.$setVisible(treeViewId, isVisible)));
+        this._register(treeView.onDidChangeCheckboxState(items => {
+            this._proxy.$changeCheckboxState(treeViewId, ( items.map(item => {
+                return { treeItemHandle: item.handle, newState: item.checkbox?.isChecked ?? false };
+            })));
+        }));
+    }
+    getTreeView(treeViewId) {
+        const viewDescriptor = ( Registry.as(Extensions.ViewsRegistry)).getView(treeViewId);
+        return viewDescriptor ? viewDescriptor.treeView : null;
+    }
+    dispose() {
+        this._dataProviders.forEach((dataProvider, treeViewId) => {
+            const treeView = this.getTreeView(treeViewId);
+            if (treeView) {
+                treeView.dataProvider = undefined;
+            }
+        });
+        this._dataProviders.clear();
+        this._dndControllers.clear();
+        super.dispose();
+    }
+};
+MainThreadTreeViews = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTreeViews),
+    ( __param(1, IViewsService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, ILogService))
+], MainThreadTreeViews);
+class TreeViewDragAndDropController {
+    constructor(treeViewId, dropMimeTypes, dragMimeTypes, hasWillDrop, _proxy) {
+        this.treeViewId = treeViewId;
+        this.dropMimeTypes = dropMimeTypes;
+        this.dragMimeTypes = dragMimeTypes;
+        this.hasWillDrop = hasWillDrop;
+        this._proxy = _proxy;
+        this.dataTransfersCache = ( new DataTransferCache());
+    }
+    async handleDrop(dataTransfer, targetTreeItem, token, operationUuid, sourceTreeId, sourceTreeItemHandles) {
+        const request = this.dataTransfersCache.add(dataTransfer);
+        try {
+            return await this._proxy.$handleDrop(this.treeViewId, request.id, await DataTransfer.toDataTransferDTO(dataTransfer), targetTreeItem?.handle, token, operationUuid, sourceTreeId, sourceTreeItemHandles);
+        }
+        finally {
+            request.dispose();
+        }
+    }
+    async handleDrag(sourceTreeItemHandles, operationUuid, token) {
+        if (!this.hasWillDrop) {
+            return;
+        }
+        const additionalDataTransferDTO = await this._proxy.$handleDrag(this.treeViewId, sourceTreeItemHandles, operationUuid, token);
+        if (!additionalDataTransferDTO) {
+            return;
+        }
+        const additionalDataTransfer = ( new VSDataTransfer());
+        additionalDataTransferDTO.items.forEach(([type, item]) => {
+            additionalDataTransfer.replace(type, createStringDataTransferItem(item.asString));
+        });
+        return additionalDataTransfer;
+    }
+    resolveDropFileData(requestId, dataItemId) {
+        return this.dataTransfersCache.resolveFileData(requestId, dataItemId);
+    }
+}
+class TreeViewDataProvider {
+    constructor(treeViewId, _proxy, notificationService) {
+        this.treeViewId = treeViewId;
+        this._proxy = _proxy;
+        this.notificationService = notificationService;
+        this.itemsMap = ( new Map());
+        this.hasResolve = this._proxy.$hasResolve(this.treeViewId);
+    }
+    getChildren(treeItem) {
+        return this._proxy.$getChildren(this.treeViewId, treeItem ? treeItem.handle : undefined)
+            .then(children => this.postGetChildren(children), err => {
+            if (!NoTreeViewError.is(err)) {
+                this.notificationService.error(err);
+            }
+            return [];
+        });
+    }
+    getItemsToRefresh(itemsToRefreshByHandle) {
+        const itemsToRefresh = [];
+        if (itemsToRefreshByHandle) {
+            for (const treeItemHandle of ( Object.keys(itemsToRefreshByHandle))) {
+                const currentTreeItem = this.getItem(treeItemHandle);
+                if (currentTreeItem) {
+                    const treeItem = itemsToRefreshByHandle[treeItemHandle];
+                    this.updateTreeItem(currentTreeItem, treeItem);
+                    if (treeItemHandle === treeItem.handle) {
+                        itemsToRefresh.push(currentTreeItem);
+                    }
+                    else {
+                        this.itemsMap.delete(treeItemHandle);
+                        this.itemsMap.set(currentTreeItem.handle, currentTreeItem);
+                        const parent = treeItem.parentHandle ? this.itemsMap.get(treeItem.parentHandle) : null;
+                        if (parent) {
+                            itemsToRefresh.push(parent);
+                        }
+                    }
+                }
+            }
+        }
+        return itemsToRefresh;
+    }
+    getItem(treeItemHandle) {
+        return this.itemsMap.get(treeItemHandle);
+    }
+    isEmpty() {
+        return this.itemsMap.size === 0;
+    }
+    async postGetChildren(elements) {
+        if (elements === undefined) {
+            return undefined;
+        }
+        const result = [];
+        const hasResolve = await this.hasResolve;
+        if (elements) {
+            for (const element of elements) {
+                const resolvable = ( new ResolvableTreeItem(element, hasResolve ? (token) => {
+                    return this._proxy.$resolve(this.treeViewId, element.handle, token);
+                } : undefined));
+                this.itemsMap.set(element.handle, resolvable);
+                result.push(resolvable);
+            }
+        }
+        return result;
+    }
+    updateTreeItem(current, treeItem) {
+        treeItem.children = treeItem.children ? treeItem.children : undefined;
+        if (current) {
+            const properties = distinct([...( Object.keys(current instanceof ResolvableTreeItem ? current.asTreeItem() : current)),
+                ...( Object.keys(treeItem))]);
+            for (const property of properties) {
+                current[property] = treeItem[property];
+            }
+            if (current instanceof ResolvableTreeItem) {
+                current.resetResolve();
+            }
+        }
+    }
+}
+export { MainThreadTreeViews };

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

@@ -21,6 +21,8 @@ import { ISearchService } from '../../services/search/common/search.js';
 import { IWorkspaceEditingService } from '../../services/workspaces/common/workspaceEditing.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { IEditSessionIdentityService } from '../../../platform/workspace/common/editSessions.js';
+import { SideBySideEditor, EditorResourceAccessor } from '../../common/editor.js';
+import { firstOrDefault, coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
 let MainThreadWorkspace = class MainThreadWorkspace {
     constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService) {
         this._searchService = _searchService;
@@ -174,8 +176,26 @@ let MainThreadWorkspace = class MainThreadWorkspace {
     $checkExists(folders, includes, token) {
         return this._instantiationService.invokeFunction((accessor) => checkGlobFileExists(accessor, folders, includes, token));
     }
+    async $save(uriComponents, options) {
+        const uri = URI.revive(uriComponents);
+        const editors = [...this._editorService.findEditors(uri, { supportSideBySide: SideBySideEditor.PRIMARY })];
+        const result = await this._editorService.save(editors, {
+            reason: 1 ,
+            saveAs: options.saveAs,
+            force: !options.saveAs
+        });
+        return firstOrDefault(this._saveResultToUris(result));
+    }
+    _saveResultToUris(result) {
+        if (!result.success) {
+            return [];
+        }
+        return coalesce(( result.editors.map(
+            editor => EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY })
+        )));
+    }
     $saveAll(includeUntitled) {
-        return this._editorService.saveAll({ includeUntitled });
+        return this._editorService.saveAll({ includeUntitled }).then(res => res.success);
     }
     $resolveProxy(url) {
         return this._requestService.resolveProxy(url);