@codingame/monaco-vscode-api 1.83.15-next.0 → 1.83.15

package/vscode/src/vs/workbench/services/extensions/browser/extensionUrlHandler.js

@@ -1,15 +1,34 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { combinedDisposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IExtensionManagementService, IExtensionGalleryService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { IWorkbenchExtensionEnablementService } from '../../extensionManagement/common/extensionManagement.js';
+import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { IURLService } from '../../../../platform/url/common/url.js';
+import { IHostService } from '../../host/browser/host.js';
+import { toExtensionDescription, IExtensionService } from '../common/extensions.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from '../../../common/contributions.js';
 import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { IsWebContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 var ExtensionUrlBootstrapHandler_1;
+const FIVE_MINUTES = 5 * 60 * 1000;
+const THIRTY_SECONDS = 30 * 1000;
+const URL_TO_HANDLE = 'extensionUrlHandler.urlToHandle';
+const USER_TRUSTED_EXTENSIONS_CONFIGURATION_KEY = 'extensions.confirmedUriHandlerExtensionIds';
 const USER_TRUSTED_EXTENSIONS_STORAGE_KEY = 'extensionUrlHandler.confirmedExtensions';
 function isExtensionId(value) {
     return /^[a-z0-9][a-z0-9\-]*\.[a-z0-9][a-z0-9\-]*$/i.test(value);
@@ -38,6 +57,293 @@ class UserTrustedExtensionIdStorage {
     }
 }
 const IExtensionUrlHandler = ( createDecorator('extensionUrlHandler'));
+let ExtensionUrlHandler = class ExtensionUrlHandler {
+    constructor(urlService, extensionService, dialogService, notificationService, extensionManagementService, extensionEnablementService, hostService, galleryService, storageService, configurationService, progressService, telemetryService, productService) {
+        this.extensionService = extensionService;
+        this.dialogService = dialogService;
+        this.notificationService = notificationService;
+        this.extensionManagementService = extensionManagementService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.hostService = hostService;
+        this.galleryService = galleryService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.progressService = progressService;
+        this.telemetryService = telemetryService;
+        this.productService = productService;
+        this.extensionHandlers = ( new Map());
+        this.uriBuffer = ( new Map());
+        this.userTrustedExtensionsStorage = ( new UserTrustedExtensionIdStorage(storageService));
+        const interval = setInterval(() => this.garbageCollect(), THIRTY_SECONDS);
+        const urlToHandleValue = this.storageService.get(URL_TO_HANDLE, 1 );
+        if (urlToHandleValue) {
+            this.storageService.remove(URL_TO_HANDLE, 1 );
+            this.handleURL(URI.revive(JSON.parse(urlToHandleValue)), { trusted: true });
+        }
+        this.disposable = combinedDisposable(urlService.registerHandler(this), toDisposable(() => clearInterval(interval)));
+        const cache = ExtensionUrlBootstrapHandler.cache;
+        setTimeout(() => cache.forEach(([uri, option]) => this.handleURL(uri, option)));
+    }
+    async handleURL(uri, options) {
+        if (!isExtensionId(uri.authority)) {
+            return false;
+        }
+        const extensionId = uri.authority;
+        this.telemetryService.publicLog2('uri_invoked/start', { extensionId });
+        const initialHandler = this.extensionHandlers.get(ExtensionIdentifier.toKey(extensionId));
+        let extensionDisplayName;
+        if (!initialHandler) {
+            const extension = await this.extensionService.getExtension(extensionId);
+            if (!extension) {
+                await this.handleUnhandledURL(uri, { id: extensionId }, options);
+                return true;
+            }
+            else {
+                extensionDisplayName = extension.displayName ?? '';
+            }
+        }
+        else {
+            extensionDisplayName = initialHandler.extensionDisplayName;
+        }
+        const trusted = options?.trusted
+            || this.productService.trustedExtensionProtocolHandlers?.includes(extensionId)
+            || this.didUserTrustExtension(ExtensionIdentifier.toKey(extensionId));
+        if (!trusted) {
+            let uriString = ( uri.toString(false));
+            if (uriString.length > 40) {
+                uriString = `${uriString.substring(0, 30)}...${uriString.substring(uriString.length - 5)}`;
+            }
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'confirmUrl',
+                    "Allow '{0}' extension to open this URI?",
+                    extensionDisplayName
+                )),
+                checkbox: {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                        'rememberConfirmUrl',
+                        "Don't ask again for this extension."
+                    )),
+                },
+                detail: uriString,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'open', comment: ['&& denotes a mnemonic'] },
+                    "&&Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/cancel', { extensionId });
+                return true;
+            }
+            if (result.checkboxChecked) {
+                this.userTrustedExtensionsStorage.add(ExtensionIdentifier.toKey(extensionId));
+            }
+        }
+        const handler = this.extensionHandlers.get(ExtensionIdentifier.toKey(extensionId));
+        if (handler) {
+            if (!initialHandler) {
+                return await this.handleURLByExtension(extensionId, handler, uri, options);
+            }
+            return false;
+        }
+        const timestamp = ( new Date()).getTime();
+        let uris = this.uriBuffer.get(ExtensionIdentifier.toKey(extensionId));
+        if (!uris) {
+            uris = [];
+            this.uriBuffer.set(ExtensionIdentifier.toKey(extensionId), uris);
+        }
+        uris.push({ timestamp, uri });
+        await this.extensionService.activateByEvent(`onUri:${ExtensionIdentifier.toKey(extensionId)}`, 1 );
+        return true;
+    }
+    registerExtensionHandler(extensionId, handler) {
+        this.extensionHandlers.set(ExtensionIdentifier.toKey(extensionId), handler);
+        const uris = this.uriBuffer.get(ExtensionIdentifier.toKey(extensionId)) || [];
+        for (const { uri } of uris) {
+            this.handleURLByExtension(extensionId, handler, uri);
+        }
+        this.uriBuffer.delete(ExtensionIdentifier.toKey(extensionId));
+    }
+    unregisterExtensionHandler(extensionId) {
+        this.extensionHandlers.delete(ExtensionIdentifier.toKey(extensionId));
+    }
+    async handleURLByExtension(extensionId, handler, uri, options) {
+        this.telemetryService.publicLog2('uri_invoked/end', { extensionId: ExtensionIdentifier.toKey(extensionId) });
+        return await handler.handleURL(uri, options);
+    }
+    async handleUnhandledURL(uri, extensionIdentifier, options) {
+        const installedExtensions = await this.extensionManagementService.getInstalled();
+        let extension = installedExtensions.find(e => areSameExtensions(e.identifier, extensionIdentifier));
+        if (!extension) {
+            let galleryExtension;
+            try {
+                galleryExtension = (await this.galleryService.getExtensions([extensionIdentifier], CancellationToken.None))[0] ?? undefined;
+            }
+            catch (err) {
+                return;
+            }
+            if (!galleryExtension) {
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/install_extension/start', { extensionId: extensionIdentifier.id });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'installAndHandle',
+                    "Would you like to install '{0}' extension from '{1}' to open this URI?",
+                    galleryExtension.displayName,
+                    galleryExtension.publisherDisplayName
+                )),
+                detail: `${( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'installDetail',
+                    "'{0}' extension wants to open a URI:",
+                    galleryExtension.displayName
+                ))}\n\n${( uri.toString())}`,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'install and open', comment: ['&& denotes a mnemonic'] },
+                    "&&Install and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/install_extension/cancel', { extensionId: extensionIdentifier.id });
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/install_extension/accept', { extensionId: extensionIdentifier.id });
+            try {
+                extension = await this.progressService.withProgress({
+                    location: 15 ,
+                    title: ( localizeWithPath(
+                        'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                        'Installing',
+                        "Installing Extension '{0}'...",
+                        galleryExtension.displayName || galleryExtension.name
+                    ))
+                }, () => this.extensionManagementService.installFromGallery(galleryExtension));
+            }
+            catch (error) {
+                this.notificationService.error(error);
+                return;
+            }
+        }
+        if (!this.extensionEnablementService.isEnabled(extension)) {
+            this.telemetryService.publicLog2('uri_invoked/enable_extension/start', { extensionId: extensionIdentifier.id });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'enableAndHandle',
+                    "Extension '{0}' is disabled. Would you like to enable the extension and open the URL?",
+                    extension.manifest.displayName || extension.manifest.name
+                )),
+                detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:\n\n${( uri.toString())}`,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'enableAndReload', comment: ['&& denotes a mnemonic'] },
+                    "&&Enable and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/enable_extension/cancel', { extensionId: extensionIdentifier.id });
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/enable_extension/accept', { extensionId: extensionIdentifier.id });
+            await this.extensionEnablementService.setEnablement([extension], 8 );
+        }
+        if (this.extensionService.canAddExtension(toExtensionDescription(extension))) {
+            await this.waitUntilExtensionIsAdded(extensionIdentifier);
+            await this.handleURL(uri, { ...options, trusted: true });
+        }
+        else {
+            this.telemetryService.publicLog2('uri_invoked/activate_extension/start', { extensionId: extensionIdentifier.id });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'reloadAndHandle',
+                    "Extension '{0}' is not loaded. Would you like to reload the window to load the extension and open the URL?",
+                    extension.manifest.displayName || extension.manifest.name
+                )),
+                detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:\n\n${( uri.toString())}`,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'reloadAndOpen', comment: ['&& denotes a mnemonic'] },
+                    "&&Reload Window and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/activate_extension/cancel', { extensionId: extensionIdentifier.id });
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/activate_extension/accept', { extensionId: extensionIdentifier.id });
+            this.storageService.store(URL_TO_HANDLE, JSON.stringify(uri.toJSON()), 1 , 1 );
+            await this.hostService.reload();
+        }
+    }
+    async waitUntilExtensionIsAdded(extensionId) {
+        if (!(await this.extensionService.getExtension(extensionId.id))) {
+            await ( new Promise((c, e) => {
+                const disposable = this.extensionService.onDidChangeExtensions(async () => {
+                    try {
+                        if (await this.extensionService.getExtension(extensionId.id)) {
+                            disposable.dispose();
+                            c();
+                        }
+                    }
+                    catch (error) {
+                        e(error);
+                    }
+                });
+            }));
+        }
+    }
+    garbageCollect() {
+        const now = ( new Date()).getTime();
+        const uriBuffer = ( new Map());
+        this.uriBuffer.forEach((uris, extensionId) => {
+            uris = uris.filter(({ timestamp }) => now - timestamp < FIVE_MINUTES);
+            if (uris.length > 0) {
+                uriBuffer.set(extensionId, uris);
+            }
+        });
+        this.uriBuffer = uriBuffer;
+    }
+    didUserTrustExtension(id) {
+        if (( this.userTrustedExtensionsStorage.has(id))) {
+            return true;
+        }
+        return this.getConfirmedTrustedExtensionIdsFromConfiguration().indexOf(id) > -1;
+    }
+    getConfirmedTrustedExtensionIdsFromConfiguration() {
+        const trustedExtensionIds = this.configurationService.getValue(USER_TRUSTED_EXTENSIONS_CONFIGURATION_KEY);
+        if (!Array.isArray(trustedExtensionIds)) {
+            return [];
+        }
+        return trustedExtensionIds;
+    }
+    dispose() {
+        this.disposable.dispose();
+        this.extensionHandlers.clear();
+        this.uriBuffer.clear();
+    }
+};
+ExtensionUrlHandler = ( __decorate([
+    ( __param(0, IURLService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IExtensionManagementService)),
+    ( __param(5, IWorkbenchExtensionEnablementService)),
+    ( __param(6, IHostService)),
+    ( __param(7, IExtensionGalleryService)),
+    ( __param(8, IStorageService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, IProgressService)),
+    ( __param(11, ITelemetryService)),
+    ( __param(12, IProductService))
+], ExtensionUrlHandler));
 let ExtensionUrlBootstrapHandler = class ExtensionUrlBootstrapHandler {
     static { ExtensionUrlBootstrapHandler_1 = this; }
     static { this._cache = []; }
@@ -104,4 +410,4 @@ class ManageAuthorizedExtensionURIsAction extends Action2 {
     }
 }
 registerAction2(ManageAuthorizedExtensionURIsAction);
-export { IExtensionUrlHandler };
+export { ExtensionUrlHandler, IExtensionUrlHandler };

package/vscode/src/vs/workbench/services/textfile/common/textfiles.js

@@ -1,7 +1,7 @@
 import { FileOperationError } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isUndefinedOrNull, areFunctions } from 'monaco-editor/esm/vs/base/common/types.js';
 const ITextFileService = ( createDecorator('textFileService'));
 class TextFileOperationError extends FileOperationError {
     static isTextFileOperationError(obj) {
@@ -13,6 +13,10 @@ class TextFileOperationError extends FileOperationError {
         this.options = options;
     }
 }
+function isTextFileEditorModel(model) {
+    const candidate = model;
+    return areFunctions(candidate.setEncoding, candidate.getEncoding, candidate.save, candidate.revert, candidate.isDirty, candidate.getLanguageId);
+}
 function stringToSnapshot(value) {
     let done = false;
     return {
@@ -42,4 +46,4 @@ function toBufferOrReadable(value) {
         }
     };
 }
-export { ITextFileService, TextFileOperationError, stringToSnapshot, toBufferOrReadable };
+export { ITextFileService, TextFileOperationError, isTextFileEditorModel, stringToSnapshot, toBufferOrReadable };