@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.7

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

@@ -1,69 +0,0 @@
-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

@@ -1,298 +0,0 @@
-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, 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.resolveDropFileData(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 => {
-            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 };