@codingame/monaco-vscode-api 1.79.7-next.1 → 1.79.7-next.2

package/dist/ext-hosts/statusBar.js

@@ -0,0 +1,15 @@
+import { ExtHostContext } from '../vscode/vs/workbench/api/common/extHost.protocol.js';
+import { IExtHostRpcService } from '../vscode/vs/workbench/api/common/extHostRpcService.js';
+import { ExtHostStatusBar } from '../vscode/vs/workbench/api/common/extHostStatusBar.js';
+import { registerExtHostProvider } from '../extHost.js';
+import '../vscode/vs/workbench/api/browser/mainThreadStatusBar.js';
+registerExtHostProvider('statusBar', {
+    dependencies: ['commands'],
+    provide: (accessor, _, { extHostCommands }) => {
+        const rpcProtocol = accessor.get(IExtHostRpcService);
+        const extHostStatusBar = rpcProtocol.set(ExtHostContext.ExtHostStatusBar, new ExtHostStatusBar(rpcProtocol, extHostCommands?.converter));
+        return {
+            extHostStatusBar
+        };
+    }
+});

package/dist/ext-hosts/storage.js

@@ -0,0 +1,28 @@
+import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
+import { IExtHostRpcService } from '../vscode/vs/workbench/api/common/extHostRpcService.js';
+import { ExtHostContext } from '../vscode/vs/workbench/api/common/extHost.protocol.js';
+import { IExtHostStorage, ExtHostStorage } from '../vscode/vs/workbench/api/common/extHostStorage.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { registerExtHostSingleton, registerExtHostProvider } from '../extHost.js';
+import '../vscode/vs/workbench/api/browser/mainThreadStorage.js';
+let _ExtHostStorage = class _ExtHostStorage extends ExtHostStorage {
+    constructor(extHostRpc, _logService) {
+        super(extHostRpc, _logService);
+    }
+};
+_ExtHostStorage = __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, ILogService))
+], _ExtHostStorage);
+registerExtHostSingleton(IExtHostStorage, _ExtHostStorage, 0 );
+registerExtHostProvider('storage', {
+    dependencies: [],
+    provide: (accessor) => {
+        const rpcProtocol = accessor.get(IExtHostRpcService);
+        const extHostStorage = accessor.get(IExtHostStorage);
+        rpcProtocol.set(ExtHostContext.ExtHostStorage, extHostStorage);
+        return {
+            extHostStorage
+        };
+    }
+});

package/dist/ext-hosts/telemetry.js

@@ -0,0 +1,17 @@
+import { IExtHostRpcService } from '../vscode/vs/workbench/api/common/extHostRpcService.js';
+import { ExtHostTelemetry, IExtHostTelemetry } from '../vscode/vs/workbench/api/common/extHostTelemetry.js';
+import { ExtHostContext } from '../vscode/vs/workbench/api/common/extHost.protocol.js';
+import { registerExtHostSingleton, registerExtHostProvider } from '../extHost.js';
+import '../vscode/vs/workbench/api/browser/mainThreadTelemetry.js';
+registerExtHostSingleton(IExtHostTelemetry, ExtHostTelemetry, 0 );
+registerExtHostProvider('telemetry', {
+    dependencies: [],
+    provide: (accessor) => {
+        const rpcProtocol = accessor.get(IExtHostRpcService);
+        const extHostTelemetry = accessor.get(IExtHostTelemetry);
+        rpcProtocol.set(ExtHostContext.ExtHostTelemetry, extHostTelemetry);
+        return {
+            extHostTelemetry
+        };
+    }
+});

package/dist/ext-hosts/terminal.js

@@ -0,0 +1,17 @@
+import { ExtHostContext } from '../vscode/vs/workbench/api/common/extHost.protocol.js';
+import { IExtHostRpcService } from '../vscode/vs/workbench/api/common/extHostRpcService.js';
+import { IExtHostTerminalService } from '../vscode/vs/workbench/api/common/extHostTerminalService.js';
+import { ExtHostTerminalService } from '../vscode/vs/workbench/api/node/extHostTerminalService.js';
+import { registerExtHostSingleton, registerExtHostProvider } from '../extHost.js';
+import '../vscode/vs/workbench/api/browser/mainThreadTerminalService.js';
+registerExtHostSingleton(IExtHostTerminalService, ExtHostTerminalService, 0 );
+registerExtHostProvider('terminal', {
+    dependencies: [],
+    provide: (accessor) => {
+        const rpcProtocol = accessor.get(IExtHostRpcService);
+        const extHostTerminalService = rpcProtocol.set(ExtHostContext.ExtHostTerminalService, accessor.get(IExtHostTerminalService));
+        return {
+            extHostTerminalService
+        };
+    }
+});

package/dist/ext-hosts/theming.js

@@ -0,0 +1,15 @@
+import { ExtHostContext } from '../vscode/vs/workbench/api/common/extHost.protocol.js';
+import { IExtHostRpcService } from '../vscode/vs/workbench/api/common/extHostRpcService.js';
+import { ExtHostTheming } from '../vscode/vs/workbench/api/common/extHostTheming.js';
+import { registerExtHostProvider } from '../extHost.js';
+import '../vscode/vs/workbench/api/browser/mainThreadTheming.js';
+registerExtHostProvider('theming', {
+    dependencies: [],
+    provide: (accessor) => {
+        const rpcProtocol = accessor.get(IExtHostRpcService);
+        const extHostTheming = rpcProtocol.set(ExtHostContext.ExtHostTheming, new ExtHostTheming(rpcProtocol));
+        return {
+            extHostTheming
+        };
+    }
+});

package/dist/ext-hosts/views.js

@@ -0,0 +1,30 @@
+import { ExtHostContext, MainContext } from '../vscode/vs/workbench/api/common/extHost.protocol.js';
+import { IExtHostRpcService } from '../vscode/vs/workbench/api/common/extHostRpcService.js';
+import { ExtHostWebviews } from '../vscode/vs/workbench/api/common/extHostWebview.js';
+import { ExtHostWebviewPanels } from '../vscode/vs/workbench/api/common/extHostWebviewPanels.js';
+import { ExtHostCustomEditors } from '../vscode/vs/workbench/api/common/extHostCustomEditors.js';
+import { ExtHostWebviewViews } from '../vscode/vs/workbench/api/common/extHostWebviewView.js';
+import { IExtensionStoragePaths } from '../vscode/vs/workbench/api/common/extHostStoragePaths.js';
+import { ExtHostTreeViews } from '../vscode/vs/workbench/api/common/extHostTreeViews.js';
+import { registerExtHostProvider } from '../extHost.js';
+import '../vscode/vs/workbench/api/browser/mainThreadWebviewManager.js';
+import '../vscode/vs/workbench/api/browser/mainThreadTreeViews.js';
+registerExtHostProvider('views', {
+    dependencies: ['commands', 'documentsAndEditors', 'workspace'],
+    provide: (accessor, _, { extHostApiDeprecationService, extHostLogService, extHostCommands, extHostInitData, extHostDocuments, extHostWorkspace }) => {
+        const rpcProtocol = accessor.get(IExtHostRpcService);
+        const extensionStoragePaths = accessor.get(IExtensionStoragePaths);
+        const extHostWebviews = rpcProtocol.set(ExtHostContext.ExtHostWebviews, new ExtHostWebviews(rpcProtocol, extHostInitData.remote, extHostWorkspace, extHostLogService, extHostApiDeprecationService));
+        const extHostWebviewPanels = rpcProtocol.set(ExtHostContext.ExtHostWebviewPanels, new ExtHostWebviewPanels(rpcProtocol, extHostWebviews, extHostWorkspace));
+        const extHostCustomEditors = rpcProtocol.set(ExtHostContext.ExtHostCustomEditors, new ExtHostCustomEditors(rpcProtocol, extHostDocuments, extensionStoragePaths, extHostWebviews, extHostWebviewPanels));
+        const extHostWebviewViews = rpcProtocol.set(ExtHostContext.ExtHostWebviewViews, new ExtHostWebviewViews(rpcProtocol, extHostWebviews));
+        const extHostTreeViews = rpcProtocol.set(ExtHostContext.ExtHostTreeViews, new ExtHostTreeViews(( rpcProtocol.getProxy(MainContext.MainThreadTreeViews)), extHostCommands, extHostLogService));
+        return {
+            extHostWebviews,
+            extHostWebviewPanels,
+            extHostCustomEditors,
+            extHostWebviewViews,
+            extHostTreeViews
+        };
+    }
+});

package/dist/ext-hosts/window.js

@@ -0,0 +1,20 @@
+import { ExtHostContext } from '../vscode/vs/workbench/api/common/extHost.protocol.js';
+import { IExtHostRpcService } from '../vscode/vs/workbench/api/common/extHostRpcService.js';
+import { ExtHostWindow, IExtHostWindow } from '../vscode/vs/workbench/api/common/extHostWindow.js';
+import { ExtHostUriOpeners } from '../vscode/vs/workbench/api/common/extHostUriOpener.js';
+import { registerExtHostSingleton, registerExtHostProvider } from '../extHost.js';
+import '../vscode/vs/workbench/api/browser/mainThreadWindow.js';
+import '../vscode/vs/workbench/api/browser/mainThreadUriOpeners.js';
+registerExtHostSingleton(IExtHostWindow, ExtHostWindow, 0 );
+registerExtHostProvider('window', {
+    dependencies: [],
+    provide: (accessor) => {
+        const rpcProtocol = accessor.get(IExtHostRpcService);
+        const extHostWindow = rpcProtocol.set(ExtHostContext.ExtHostWindow, accessor.get(IExtHostWindow));
+        const extHostUriOpeners = rpcProtocol.set(ExtHostContext.ExtHostUriOpeners, new ExtHostUriOpeners(rpcProtocol));
+        return {
+            extHostWindow,
+            extHostUriOpeners
+        };
+    }
+});

package/dist/ext-hosts/workspace.js

@@ -0,0 +1,16 @@
+import { ExtHostContext } from '../vscode/vs/workbench/api/common/extHost.protocol.js';
+import { IExtHostRpcService } from '../vscode/vs/workbench/api/common/extHostRpcService.js';
+import { ExtHostWorkspace, IExtHostWorkspace } from '../vscode/vs/workbench/api/common/extHostWorkspace.js';
+import { registerExtHostSingleton, registerExtHostProvider } from '../extHost.js';
+import '../vscode/vs/workbench/api/browser/mainThreadWorkspace.js';
+registerExtHostSingleton(IExtHostWorkspace, ExtHostWorkspace, 0 );
+registerExtHostProvider('workspace', {
+    dependencies: [],
+    provide: (accessor) => {
+        const rpcProtocol = accessor.get(IExtHostRpcService);
+        const extHostWorkspace = rpcProtocol.set(ExtHostContext.ExtHostWorkspace, accessor.get(IExtHostWorkspace));
+        return {
+            extHostWorkspace
+        };
+    }
+});

package/dist/extHost.js

@@ -0,0 +1,271 @@
+import { ExtHostExtensionService } from './vscode/vs/workbench/api/worker/extHostExtensionService.js';
+import { IExtHostManagedSockets } from './vscode/vs/workbench/api/common/extHostManagedSockets.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtHostInitDataService } from './vscode/vs/workbench/api/common/extHostInitDataService.js';
+import { UIKind } from './vscode/vs/workbench/services/extensions/common/extensionHostProtocol.js';
+import { ExtHostVariableResolverProviderService, IExtHostVariableResolverProvider } from './vscode/vs/workbench/api/common/extHostVariableResolverService.js';
+import { IHostUtils, IExtHostExtensionService } from './vscode/vs/workbench/api/common/extHostExtensionService.js';
+import { ExtensionStoragePaths, IExtensionStoragePaths } from './vscode/vs/workbench/api/common/extHostStoragePaths.js';
+import { ExtHostTunnelService, IExtHostTunnelService } from './vscode/vs/workbench/api/common/extHostTunnelService.js';
+import { ExtHostRpcService, IExtHostRpcService } from './vscode/vs/workbench/api/common/extHostRpcService.js';
+import { ILogService, ILoggerService, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ExtHostCustomersRegistry } from './vscode/vs/workbench/services/extensions/common/extHostCustomers.js';
+import { ExtHostApiDeprecationService, IExtHostApiDeprecationService } from './vscode/vs/workbench/api/common/extHostApiDeprecationService.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { ExtHostContext } from './vscode/vs/workbench/api/common/extHost.protocol.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { BufferedEmitter } from './vscode/vs/base/parts/ipc/common/ipc.net.js';
+import { RPCProtocol } from './vscode/vs/workbench/services/extensions/common/rpcProtocol.js';
+import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Barrier } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IExtensionService } from './vscode/vs/workbench/services/extensions/common/extensions.js';
+import { array } from './node_modules/toposort/index.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { InstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiationService.js';
+import { ExtHostLogService } from './vscode/vs/workbench/api/common/extHostLogService.js';
+import { ExtHostLoggerService } from './vscode/vs/workbench/api/common/extHostLoggerService.js';
+import { IURITransformerService, URITransformerService } from './vscode/vs/workbench/api/common/extHostUriTransformerService.js';
+import { unsupported } from './tools.js';
+import './vscode/vs/workbench/api/browser/mainThreadConsole.js';
+import './vscode/vs/workbench/api/browser/mainThreadExtensionService.js';
+import './vscode/vs/workbench/api/browser/mainThreadLogService.js';
+const serviceCollection = new ServiceCollection();
+function registerExtHostSingleton(id, ctorOrDescriptor, supportsDelayedInstantiation) {
+    if (!(ctorOrDescriptor instanceof SyncDescriptor)) {
+        ctorOrDescriptor = new SyncDescriptor(ctorOrDescriptor, [], Boolean(supportsDelayedInstantiation));
+    }
+    serviceCollection.set(id, ctorOrDescriptor);
+}
+serviceCollection.set(IURITransformerService, new URITransformerService(null));
+const extHostInstantiationService = new InstantiationService(serviceCollection, false);
+serviceCollection.set(IInstantiationService, extHostInstantiationService);
+class SimpleMessagePassingProtocol {
+    constructor() {
+        this._onMessage = new BufferedEmitter();
+        this.onMessage = this._onMessage.event;
+    }
+    send(buffer) {
+        setTimeout(() => {
+            this._onMessage.fire(buffer);
+        });
+    }
+}
+const imessagePassingProtocol = new SimpleMessagePassingProtocol();
+const rpcProtocol = new RPCProtocol(imessagePassingProtocol);
+const environment = {
+    isExtensionDevelopmentDebug: false,
+    appName: 'Monaco',
+    appHost: 'web',
+    appLanguage: window.navigator.language ?? 'en-US',
+    extensionTelemetryLogResource: ( URI.from({ scheme: 'user', path: '/extensionTelemetryLogResource.log' })),
+    isExtensionTelemetryLoggingOnly: false,
+    get appUriScheme() { return unsupported(); },
+    get globalStorageHome() { return unsupported(); },
+    get workspaceStorageHome() { return unsupported(); }
+};
+registerExtHostSingleton(ILogService, new SyncDescriptor(ExtHostLogService, [true], true));
+registerExtHostSingleton(ILoggerService, ExtHostLoggerService, 1 );
+class ExtHostInitDataService {
+    constructor(_telemetryService) {
+        this._telemetryService = _telemetryService;
+        this.quality = undefined;
+        this.version = '1.0.0';
+        this.parentPid = 0;
+        this.environment = environment;
+        this.allExtensions = [];
+        this.myExtensions = [];
+        this.consoleForward = {
+            includeStack: false,
+            logNative: false
+        };
+        this.logLevel = LogLevel.Off;
+        this.logsLocation = ( URI.from({ scheme: 'logs', path: '/' }));
+        this.logFile = ( URI.from({ scheme: 'logs', path: '/logs.log' }));
+        this.autoStart = true;
+        this.remote = {
+            isRemote: false,
+            authority: undefined,
+            connectionData: null
+        };
+        this.uiKind = UIKind.Web;
+        this.loggers = [];
+        this.logName = 'browser';
+        this.activationEvents = {};
+    }
+    get telemetryInfo() {
+        return this._telemetryService;
+    }
+}
+registerExtHostSingleton(IHostUtils, class HostUtils {
+    constructor() {
+        this.pid = undefined;
+    }
+    exit() {
+        window.close();
+    }
+    async exists() {
+        return true;
+    }
+    async realpath(path) {
+        return path;
+    }
+}, 1 );
+registerExtHostSingleton(IExtHostRpcService, new SyncDescriptor(ExtHostRpcService, [rpcProtocol], true));
+registerExtHostSingleton(IExtensionStoragePaths, ExtensionStoragePaths, 1 );
+class _ExtHostExtensionService extends ExtHostExtensionService {
+    getExtensionRegistries() {
+        return { mine: this._myRegistry, all: this._globalRegistry };
+    }
+}
+registerExtHostSingleton(IExtHostExtensionService, _ExtHostExtensionService, 1 );
+registerExtHostSingleton(IExtHostTunnelService, ExtHostTunnelService, 1 );
+registerExtHostSingleton(IExtHostApiDeprecationService, ExtHostApiDeprecationService, 1 );
+registerExtHostSingleton(IExtHostVariableResolverProvider, ExtHostVariableResolverProviderService, 1 );
+registerExtHostSingleton(IExtHostManagedSockets, class ExtHostManagedSockets {
+    constructor() {
+        this.setFactory = () => {
+        };
+        this.$openRemoteSocket = unsupported;
+        this.$remoteSocketWrite = unsupported;
+        this.$remoteSocketEnd = unsupported;
+        this.$remoteSocketDrain = unsupported;
+    }
+}, 1 );
+const mainContext = {
+    remoteAuthority: null,
+    extensionHostKind: 1 ,
+    internalExtensionService: {
+        _activateById() {
+            return Promise.resolve();
+        },
+        _onWillActivateExtension() {
+        },
+        _onDidActivateExtension() {
+        },
+        _onDidActivateExtensionError() {
+        },
+        _onExtensionRuntimeError() {
+        }
+    },
+    getProxy: function (identifier) {
+        return ( rpcProtocol.getProxy(identifier));
+    },
+    set: function (identifier, instance) {
+        return rpcProtocol.set(identifier, instance);
+    },
+    assertRegistered: function (identifiers) {
+        rpcProtocol.assertRegistered(identifiers);
+    },
+    drain: function () {
+        return rpcProtocol.drain();
+    },
+    dispose() {
+        rpcProtocol.dispose();
+    },
+    _setExtensionHostProxy(proxy) {
+        StandaloneServices.get(IExtensionService).setExtensionHostProxy(proxy);
+    },
+    _setAllMainProxyIdentifiers() { }
+};
+const extHostProviders = new Map();
+function registerExtHostProvider(name, provider) {
+    extHostProviders.set(name, provider);
+}
+function createExtHostServices(accessor) {
+    registerExtHostSingleton(IExtHostInitDataService, new SyncDescriptor(ExtHostInitDataService, [StandaloneServices.get(ITelemetryService)], true));
+    const rpcProtocol = accessor.get(IExtHostRpcService);
+    const logService = accessor.get(ILogService);
+    const extHostApiDeprecationService = accessor.get(IExtHostApiDeprecationService);
+    const extHostTunnelService = accessor.get(IExtHostTunnelService);
+    const extHostInitData = accessor.get(IExtHostInitDataService);
+    rpcProtocol.set(ExtHostContext.ExtHostTunnelService, extHostTunnelService);
+    const extHostExtensionService = rpcProtocol.set(ExtHostContext.ExtHostExtensionService, accessor.get(IExtHostExtensionService));
+    const extHostServices = {
+        extHostInitData,
+        extHostLogService: logService,
+        extHostApiDeprecationService,
+        extHostExtensionService
+    };
+    const sortedProviders = array(Array.from(( extHostProviders.values())), Array.from(extHostProviders.entries()).flatMap(([name, provider]) => provider.dependencies?.map(dependency => {
+        const dependencyImpl = extHostProviders.get(dependency);
+        if (dependencyImpl == null) {
+            logService.warn(`ExtHost ${name} depends on not registered ${dependency}`);
+            return null;
+        }
+        return [dependencyImpl, provider];
+    }).filter((a) => a != null) ?? []));
+    for (const extHostProvider of sortedProviders) {
+        Object.assign(extHostServices, extHostProvider.provide(accessor, mainContext, extHostServices));
+    }
+    return extHostServices;
+}
+function runExtHostCustomers(accessor) {
+    const instantiationService = accessor.get(IInstantiationService);
+    const logService = accessor.get(ILogService);
+    const namedCustomers = ExtHostCustomersRegistry.getNamedCustomers();
+    for (const [id, ctor] of namedCustomers) {
+        try {
+            const instance = instantiationService.createInstance(ctor, mainContext);
+            rpcProtocol.set(id, instance);
+        }
+        catch (err) {
+            logService.error(`Cannot instantiate named customer: '${id.sid}'`);
+            logService.error(err);
+            errors.onUnexpectedError(err);
+        }
+    }
+    const customers = ExtHostCustomersRegistry.getCustomers();
+    for (const ctor of customers) {
+        try {
+            instantiationService.createInstance(ctor, mainContext);
+        }
+        catch (err) {
+            logService.error(err);
+            errors.onUnexpectedError(err);
+        }
+    }
+}
+let extHostServices;
+let configProvider;
+const extHostInitializedBarrier = new Barrier();
+function onExtHostInitialized(fct) {
+    void extHostInitializedBarrier.wait().then(fct);
+}
+async function _initialize() {
+    const partialExtHostServices = extHostInstantiationService.invokeFunction(createExtHostServices);
+    StandaloneServices.get(IInstantiationService).invokeFunction(runExtHostCustomers);
+    configProvider = await partialExtHostServices.extHostConfiguration?.getConfigProvider();
+    await partialExtHostServices.extHostExtensionService.initialize();
+    extHostServices = new Proxy(partialExtHostServices, {
+        get(target, p) {
+            const v = target[p];
+            if (v == null) {
+                StandaloneServices.get(ILogService).warn(`ExtHost ${p} not registered`);
+            }
+            return v;
+        }
+    });
+    extHostInitializedBarrier.open();
+}
+let initializePromise;
+async function initialize() {
+    if (initializePromise == null) {
+        initializePromise = _initialize();
+    }
+    await initializePromise;
+}
+function getExtHostServices() {
+    if (extHostServices == null) {
+        throw new Error('Extension api not initialized');
+    }
+    return extHostServices;
+}
+function getConfigProvider() {
+    if (configProvider == null) {
+        throw new Error('Config provider not available');
+    }
+    return configProvider;
+}
+export { extHostInstantiationService, getConfigProvider, getExtHostServices, initialize, onExtHostInitialized, registerExtHostProvider, registerExtHostSingleton };