@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.js

@@ -1,133 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { escape } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { ExtHostContext } from '../common/extHost.protocol.js';
-import { deserializeWebviewMessage, serializeWebviewMessage } from '../common/extHostWebviewMessaging.js';
-import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
-var MainThreadWebviews_1;
-let MainThreadWebviews = class MainThreadWebviews extends Disposable {
-    static { MainThreadWebviews_1 = this; }
-    static { this.standardSupportedLinkSchemes = ( new Set([
-        Schemas.http,
-        Schemas.https,
-        Schemas.mailto,
-        Schemas.vscode,
-        'vscode-insider',
-    ])); }
-    constructor(context, _openerService, _productService) {
-        super();
-        this._openerService = _openerService;
-        this._productService = _productService;
-        this._webviews = ( new Map());
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviews));
-    }
-    addWebview(handle, webview, options) {
-        if (( this._webviews.has(handle))) {
-            throw new Error('Webview already registered');
-        }
-        this._webviews.set(handle, webview);
-        this.hookupWebviewEventDelegate(handle, webview, options);
-    }
-    $setHtml(handle, value) {
-        this.tryGetWebview(handle)?.setHtml(value);
-    }
-    $setOptions(handle, options) {
-        const webview = this.tryGetWebview(handle);
-        if (webview) {
-            webview.contentOptions = reviveWebviewContentOptions(options);
-        }
-    }
-    async $postMessage(handle, jsonMessage, ...buffers) {
-        const webview = this.tryGetWebview(handle);
-        if (!webview) {
-            return false;
-        }
-        const { message, arrayBuffers } = deserializeWebviewMessage(jsonMessage, buffers);
-        return webview.postMessage(message, arrayBuffers);
-    }
-    hookupWebviewEventDelegate(handle, webview, options) {
-        const disposables = ( new DisposableStore());
-        disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
-        disposables.add(webview.onMessage((message) => {
-            const serialized = serializeWebviewMessage(message.message, options);
-            this._proxy.$onMessage(handle, serialized.message, ( new SerializableObjectWithBuffers(serialized.buffers)));
-        }));
-        disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
-        disposables.add(webview.onDidDispose(() => {
-            disposables.dispose();
-            this._webviews.delete(handle);
-        }));
-    }
-    onDidClickLink(handle, link) {
-        const webview = this.getWebview(handle);
-        if (this.isSupportedLink(webview, ( URI.parse(link)))) {
-            this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
-        }
-    }
-    isSupportedLink(webview, link) {
-        if (( MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme))) {
-            return true;
-        }
-        if (!isWeb && this._productService.urlProtocol === link.scheme) {
-            return true;
-        }
-        if (link.scheme === Schemas.command) {
-            if (Array.isArray(webview.contentOptions.enableCommandUris)) {
-                return webview.contentOptions.enableCommandUris.includes(link.path);
-            }
-            return webview.contentOptions.enableCommandUris === true;
-        }
-        return false;
-    }
-    tryGetWebview(handle) {
-        return this._webviews.get(handle);
-    }
-    getWebview(handle) {
-        const webview = this.tryGetWebview(handle);
-        if (!webview) {
-            throw new Error(`Unknown webview handle:${handle}`);
-        }
-        return webview;
-    }
-    getWebviewResolvedFailedContent(viewType) {
-        return `<!DOCTYPE html>
-		<html>
-			<head>
-				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
-				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
-			</head>
-			<body>${( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadWebviews',
-            'errorMessage',
-            "An error occurred while loading view: {0}",
-            escape(viewType)
-        ))}</body>
-		</html>`;
-    }
-};
-MainThreadWebviews = MainThreadWebviews_1 = ( __decorate([
-    ( __param(1, IOpenerService)),
-    ( __param(2, IProductService))
-], MainThreadWebviews));
-function reviveWebviewExtension(extensionData) {
-    return {
-        id: extensionData.id,
-        location: URI.revive(extensionData.location),
-    };
-}
-function reviveWebviewContentOptions(webviewOptions) {
-    return {
-        allowScripts: webviewOptions.enableScripts,
-        allowForms: webviewOptions.enableForms,
-        enableCommandUris: webviewOptions.enableCommandUris,
-        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( webviewOptions.localResourceRoots.map(r => URI.revive(r))) : undefined,
-        portMapping: webviewOptions.portMapping,
-    };
-}
-export { MainThreadWebviews, reviveWebviewContentOptions, reviveWebviewExtension };

package/vscode/src/vs/workbench/api/browser/mainThreadWindow.js

@@ -1,55 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { IHostService } from '../../services/host/browser/host.js';
-import { IUserActivityService } from '../../services/userActivity/common/userActivityService.js';
-let MainThreadWindow = class MainThreadWindow {
-    constructor(extHostContext, hostService, openerService, userActivityService) {
-        this.hostService = hostService;
-        this.openerService = openerService;
-        this.userActivityService = userActivityService;
-        this.disposables = ( new DisposableStore());
-        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWindow));
-        Event.latch(hostService.onDidChangeFocus)(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
-        userActivityService.onDidChangeIsActive(this.proxy.$onDidChangeWindowActive, this.proxy, this.disposables);
-    }
-    dispose() {
-        this.disposables.dispose();
-    }
-    $getInitialState() {
-        return Promise.resolve({
-            isFocused: this.hostService.hasFocus,
-            isActive: this.userActivityService.isActive,
-        });
-    }
-    async $openUri(uriComponents, uriString, options) {
-        const uri = ( URI.from(uriComponents));
-        let target;
-        if (uriString && ( ( URI.parse(uriString)).toString()) === ( uri.toString())) {
-            target = uriString;
-        }
-        else {
-            target = uri;
-        }
-        return this.openerService.open(target, {
-            openExternal: true,
-            allowTunneling: options.allowTunneling,
-            allowContributedOpeners: options.allowContributedOpeners,
-        });
-    }
-    async $asExternalUri(uriComponents, options) {
-        const result = await this.openerService.resolveExternalUri(URI.revive(uriComponents), options);
-        return result.resolved;
-    }
-};
-MainThreadWindow = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadWindow),
-    ( __param(1, IHostService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IUserActivityService))
-], MainThreadWindow);
-export { MainThreadWindow };

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

@@ -1,271 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IRequestService } from '../../../platform/request/common/request.js';
-import { IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
-import { isUntitledWorkspace, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { checkGlobFileExists } from '../../services/extensions/common/workspaceContains.js';
-import { QueryBuilder } from '../../services/search/common/queryBuilder.js';
-import { IEditorService } from '../../services/editor/common/editorService.js';
-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';
-import { ICanonicalUriService } from '../../../platform/workspace/common/canonicalUri.js';
-let MainThreadWorkspace = class MainThreadWorkspace {
-    constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _canonicalUriService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService) {
-        this._searchService = _searchService;
-        this._contextService = _contextService;
-        this._editSessionIdentityService = _editSessionIdentityService;
-        this._canonicalUriService = _canonicalUriService;
-        this._editorService = _editorService;
-        this._workspaceEditingService = _workspaceEditingService;
-        this._notificationService = _notificationService;
-        this._requestService = _requestService;
-        this._instantiationService = _instantiationService;
-        this._labelService = _labelService;
-        this._environmentService = _environmentService;
-        this._workspaceTrustManagementService = _workspaceTrustManagementService;
-        this._workspaceTrustRequestService = _workspaceTrustRequestService;
-        this._toDispose = ( new DisposableStore());
-        this._activeCancelTokens = Object.create(null);
-        this._queryBuilder = this._instantiationService.createInstance(QueryBuilder);
-        this.registeredEditSessionProviders = ( new Map());
-        this.registeredCanonicalUriProviders = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWorkspace));
-        const workspace = this._contextService.getWorkspace();
-        if (workspace.configuration && !isNative && !fileService.hasProvider(workspace.configuration)) {
-            this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted());
-        }
-        else {
-            this._contextService.getCompleteWorkspace().then(workspace => this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted()));
-        }
-        this._contextService.onDidChangeWorkspaceFolders(this._onDidChangeWorkspace, this, this._toDispose);
-        this._contextService.onDidChangeWorkbenchState(this._onDidChangeWorkspace, this, this._toDispose);
-        this._workspaceTrustManagementService.onDidChangeTrust(this._onDidGrantWorkspaceTrust, this, this._toDispose);
-    }
-    dispose() {
-        this._toDispose.dispose();
-        for (const requestId in this._activeCancelTokens) {
-            const tokenSource = this._activeCancelTokens[requestId];
-            tokenSource.cancel();
-        }
-    }
-    $updateWorkspaceFolders(extensionName, index, deleteCount, foldersToAdd) {
-        const workspaceFoldersToAdd = ( foldersToAdd.map(f => ({ uri: URI.revive(f.uri), name: f.name })));
-        this._notificationService.status(this.getStatusMessage(extensionName, workspaceFoldersToAdd.length, deleteCount), { hideAfter: 10 * 1000  });
-        return this._workspaceEditingService.updateFolders(index, deleteCount, workspaceFoldersToAdd, true);
-    }
-    getStatusMessage(extensionName, addCount, removeCount) {
-        let message;
-        const wantsToAdd = addCount > 0;
-        const wantsToDelete = removeCount > 0;
-        if (wantsToAdd && !wantsToDelete) {
-            if (addCount === 1) {
-                message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageAddSingleFolder',
-                    "Extension '{0}' added 1 folder to the workspace",
-                    extensionName
-                ));
-            }
-            else {
-                message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageAddMultipleFolders',
-                    "Extension '{0}' added {1} folders to the workspace",
-                    extensionName,
-                    addCount
-                ));
-            }
-        }
-        else if (wantsToDelete && !wantsToAdd) {
-            if (removeCount === 1) {
-                message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageRemoveSingleFolder',
-                    "Extension '{0}' removed 1 folder from the workspace",
-                    extensionName
-                ));
-            }
-            else {
-                message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageRemoveMultipleFolders',
-                    "Extension '{0}' removed {1} folders from the workspace",
-                    extensionName,
-                    removeCount
-                ));
-            }
-        }
-        else {
-            message = ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadWorkspace',
-                'folderStatusChangeFolder',
-                "Extension '{0}' changed folders of the workspace",
-                extensionName
-            ));
-        }
-        return message;
-    }
-    _onDidChangeWorkspace() {
-        this._proxy.$acceptWorkspaceData(this.getWorkspaceData(this._contextService.getWorkspace()));
-    }
-    getWorkspaceData(workspace) {
-        if (this._contextService.getWorkbenchState() === 1 ) {
-            return null;
-        }
-        return {
-            configuration: workspace.configuration || undefined,
-            isUntitled: workspace.configuration ? isUntitledWorkspace(workspace.configuration, this._environmentService) : false,
-            folders: workspace.folders,
-            id: workspace.id,
-            name: this._labelService.getWorkspaceLabel(workspace),
-            transient: workspace.transient
-        };
-    }
-    $startFileSearch(includePattern, _includeFolder, excludePatternOrDisregardExcludes, maxResults, token) {
-        const includeFolder = URI.revive(_includeFolder);
-        const workspace = this._contextService.getWorkspace();
-        const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, {
-            maxResults: maxResults ?? undefined,
-            disregardExcludeSettings: (excludePatternOrDisregardExcludes === false) || undefined,
-            disregardSearchExcludeSettings: true,
-            disregardIgnoreFiles: true,
-            includePattern: includePattern ?? undefined,
-            excludePattern: typeof excludePatternOrDisregardExcludes === 'string' ? excludePatternOrDisregardExcludes : undefined,
-            _reason: 'startFileSearch'
-        });
-        return this._searchService.fileSearch(query, token).then(result => {
-            return ( result.results.map(m => m.resource));
-        }, err => {
-            if (!isCancellationError(err)) {
-                return Promise.reject(err);
-            }
-            return null;
-        });
-    }
-    $startTextSearch(pattern, _folder, options, requestId, token) {
-        const folder = URI.revive(_folder);
-        const workspace = this._contextService.getWorkspace();
-        const folders = folder ? [folder] : ( workspace.folders.map(folder => folder.uri));
-        const query = this._queryBuilder.text(pattern, folders, options);
-        query._reason = 'startTextSearch';
-        const onProgress = (p) => {
-            if (p.results) {
-                this._proxy.$handleTextSearchResult(p, requestId);
-            }
-        };
-        const search = this._searchService.textSearch(query, token, onProgress).then(result => {
-            return { limitHit: result.limitHit };
-        }, err => {
-            if (!isCancellationError(err)) {
-                return Promise.reject(err);
-            }
-            return null;
-        });
-        return search;
-    }
-    $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 }).then(res => res.success);
-    }
-    $resolveProxy(url) {
-        return this._requestService.resolveProxy(url);
-    }
-    $requestWorkspaceTrust(options) {
-        return this._workspaceTrustRequestService.requestWorkspaceTrust(options);
-    }
-    isWorkspaceTrusted() {
-        return this._workspaceTrustManagementService.isWorkspaceTrusted();
-    }
-    _onDidGrantWorkspaceTrust() {
-        this._proxy.$onDidGrantWorkspaceTrust();
-    }
-    $registerEditSessionIdentityProvider(handle, scheme) {
-        const disposable = this._editSessionIdentityService.registerEditSessionIdentityProvider({
-            scheme: scheme,
-            getEditSessionIdentifier: async (workspaceFolder, token) => {
-                return this._proxy.$getEditSessionIdentifier(workspaceFolder.uri, token);
-            },
-            provideEditSessionIdentityMatch: async (workspaceFolder, identity1, identity2, token) => {
-                return this._proxy.$provideEditSessionIdentityMatch(workspaceFolder.uri, identity1, identity2, token);
-            }
-        });
-        this.registeredEditSessionProviders.set(handle, disposable);
-        this._toDispose.add(disposable);
-    }
-    $unregisterEditSessionIdentityProvider(handle) {
-        const disposable = this.registeredEditSessionProviders.get(handle);
-        disposable?.dispose();
-        this.registeredEditSessionProviders.delete(handle);
-    }
-    $registerCanonicalUriProvider(handle, scheme) {
-        const disposable = this._canonicalUriService.registerCanonicalUriProvider({
-            scheme: scheme,
-            provideCanonicalUri: async (uri, targetScheme, token) => {
-                const result = await this._proxy.$provideCanonicalUri(uri, targetScheme, token);
-                if (result) {
-                    return URI.revive(result);
-                }
-                return result;
-            }
-        });
-        this.registeredCanonicalUriProviders.set(handle, disposable);
-        this._toDispose.add(disposable);
-    }
-    $unregisterCanonicalUriProvider(handle) {
-        const disposable = this.registeredCanonicalUriProviders.get(handle);
-        disposable?.dispose();
-        this.registeredCanonicalUriProviders.delete(handle);
-    }
-};
-MainThreadWorkspace = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadWorkspace),
-    ( __param(1, ISearchService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IEditSessionIdentityService)),
-    ( __param(4, ICanonicalUriService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IWorkspaceEditingService)),
-    ( __param(7, INotificationService)),
-    ( __param(8, IRequestService)),
-    ( __param(9, IInstantiationService)),
-    ( __param(10, ILabelService)),
-    ( __param(11, IEnvironmentService)),
-    ( __param(12, IFileService)),
-    ( __param(13, IWorkspaceTrustManagementService)),
-    ( __param(14, IWorkspaceTrustRequestService))
-], MainThreadWorkspace);
-export { MainThreadWorkspace };

package/vscode/src/vs/workbench/api/common/shared/dataTransferCache.js

@@ -1,33 +0,0 @@
-import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-class DataTransferFileCache {
-    constructor() {
-        this.requestIdPool = 0;
-        this.dataTransferFiles = ( new Map());
-    }
-    add(dataTransfer) {
-        const requestId = this.requestIdPool++;
-        this.dataTransferFiles.set(requestId, coalesce(Array.from(dataTransfer, ([, item]) => item.asFile())));
-        return {
-            id: requestId,
-            dispose: () => {
-                this.dataTransferFiles.delete(requestId);
-            }
-        };
-    }
-    async resolveFileData(requestId, dataItemId) {
-        const files = this.dataTransferFiles.get(requestId);
-        if (!files) {
-            throw new Error('No data transfer found');
-        }
-        const file = files.find(file => file.id === dataItemId);
-        if (!file) {
-            throw new Error('No matching file found in data transfer');
-        }
-        return VSBuffer.wrap(await file.data());
-    }
-    dispose() {
-        this.dataTransferFiles.clear();
-    }
-}
-export { DataTransferFileCache };