@codingame/monaco-vscode-extensions-service-override/vscode/src/vs/workbench/api/browser/mainThreadUrls.js

VSCode public API plugged on the monaco editor - extensions service-override

import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
import { IURLService } from 'vscode/vscode/vs/platform/url/common/url.service';
import { IExtensionUrlHandler } from 'vscode/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler.service';
import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';

class ExtensionUrlHandler {
    constructor(proxy, handle, extensionId, extensionDisplayName) {
        this.proxy = proxy;
        this.handle = handle;
        this.extensionId = extensionId;
        this.extensionDisplayName = extensionDisplayName;
    }
    handleURL(uri, options) {
        if (!ExtensionIdentifier.equals(this.extensionId, uri.authority)) {
            return Promise.resolve(false);
        }
        return Promise.resolve(this.proxy.$handleExternalUri(this.handle, uri)).then(() => true);
    }
}
let MainThreadUrls = class MainThreadUrls {
    constructor(context, urlService, extensionUrlHandler) {
        this.urlService = urlService;
        this.extensionUrlHandler = extensionUrlHandler;
        this.handlers = ( new Map());
        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUrls));
    }
    $registerUriHandler(handle, extensionId, extensionDisplayName) {
        const handler = ( new ExtensionUrlHandler(this.proxy, handle, extensionId, extensionDisplayName));
        const disposable = this.urlService.registerHandler(handler);
        this.handlers.set(handle, { extensionId, disposable });
        this.extensionUrlHandler.registerExtensionHandler(extensionId, handler);
        return Promise.resolve(undefined);
    }
    $unregisterUriHandler(handle) {
        const tuple = this.handlers.get(handle);
        if (!tuple) {
            return Promise.resolve(undefined);
        }
        const { extensionId, disposable } = tuple;
        this.extensionUrlHandler.unregisterExtensionHandler(extensionId);
        this.handlers.delete(handle);
        disposable.dispose();
        return Promise.resolve(undefined);
    }
    async $createAppUri(uri) {
        return this.urlService.create(uri);
    }
    dispose() {
        this.handlers.forEach(({ disposable }) => disposable.dispose());
        this.handlers.clear();
    }
};
MainThreadUrls = __decorate([
    extHostNamedCustomer(MainContext.MainThreadUrls),
    ( __param(1, IURLService)),
    ( __param(2, IExtensionUrlHandler))
], MainThreadUrls);

export { MainThreadUrls };