@theia/plugin-ext 1.45.1 → 1.46.0-next.137

package/src/plugin/clipboard-ext.ts

@@ -15,15 +15,21 @@
 // *****************************************************************************
 
 import * as theia from '@theia/plugin';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { PLUGIN_RPC_CONTEXT, ClipboardMain } from '../common';
 
+@injectable()
 export class ClipboardExt implements theia.Clipboard {
 
-    protected readonly proxy: ClipboardMain;
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
 
-    constructor(rpc: RPCProtocol) {
-        this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.CLIPBOARD_MAIN);
+    protected proxy: ClipboardMain;
+
+    @postConstruct()
+    initialize(): void {
+        this.proxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.CLIPBOARD_MAIN);
     }
 
     readText(): Promise<string> {

package/src/plugin/custom-editors.ts

@@ -129,7 +129,7 @@ export class CustomEditorsExtImpl implements CustomEditorsExt {
         if (!entry) {
             throw new Error(`No provider found for '${viewType}'`);
         }
-        const panel = this.webviewExt.createWebviewPanel(viewType, title, {}, options, entry.plugin, handler);
+        const panel = this.webviewExt.createWebviewPanel(viewType, title, {}, options, entry.plugin, handler, false);
         const webviewOptions = WebviewImpl.toWebviewOptions(options, this.workspace, entry.plugin);
         await this.proxy.$createCustomEditorPanel(handler, title, widgetOpenerOptions, webviewOptions);
 

package/src/plugin/debug/debug-ext.ts

@@ -13,6 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { Emitter } from '@theia/core/lib/common/event';
 import { Path } from '@theia/core/lib/common/path';
 import * as theia from '@theia/plugin';
@@ -27,7 +28,7 @@ import { DEBUG_SCHEME, SCHEME_PATTERN } from '@theia/debug/lib/common/debug-uri-
 import { Disposable, Breakpoint as BreakpointExt, SourceBreakpoint, FunctionBreakpoint, Location, Range, URI as URIImpl } from '../types-impl';
 import { PluginDebugAdapterSession } from './plugin-debug-adapter-session';
 import { PluginDebugAdapterTracker } from './plugin-debug-adapter-tracker';
-import uuid = require('uuid');
+import { generateUuid } from '@theia/core/lib/common/uuid';
 import { DebugAdapter } from '@theia/debug/lib/common/debug-model';
 import { PluginDebugAdapterCreator } from './plugin-debug-adapter-creator';
 import { NodeDebugAdapterCreator } from '../node/debug/plugin-node-debug-adapter-creator';
@@ -43,7 +44,11 @@ interface ConfigurationProviderRecord {
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+@injectable()
 export class DebugExtImpl implements DebugExt {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
+
     // debug sessions by sessionId
     private sessions = new Map<string, PluginDebugAdapterSession>();
     private configurationProviderHandleGenerator: number;
@@ -83,8 +88,7 @@ export class DebugExtImpl implements DebugExt {
         return [...this._breakpoints.values()];
     }
 
-    constructor(rpc: RPCProtocol) {
-        this.proxy = rpc.getProxy(Ext.DEBUG_MAIN);
+    constructor() {
         this.activeDebugConsole = {
             append: (value: string) => this.proxy.$appendToDebugConsole(value),
             appendLine: (value: string) => this.proxy.$appendLineToDebugConsole(value)
@@ -93,6 +97,11 @@ export class DebugExtImpl implements DebugExt {
         this.configurationProviders = [];
     }
 
+    @postConstruct()
+    initialize(): void {
+        this.proxy = this.rpc.getProxy(Ext.DEBUG_MAIN);
+    }
+
     /**
      * Sets dependencies.
      */
@@ -336,7 +345,7 @@ export class DebugExtImpl implements DebugExt {
     }
 
     async $createDebugSession(debugConfiguration: DebugConfiguration, workspaceFolderUri: string | undefined): Promise<string> {
-        const sessionId = uuid.v4();
+        const sessionId = generateUuid();
 
         const parentSession = debugConfiguration.parentSessionId ? this.sessions.get(debugConfiguration.parentSessionId) : undefined;
         const theiaSession: theia.DebugSession = {

package/src/plugin/dialogs.ts

@@ -41,7 +41,7 @@ export class DialogsExtImpl {
                 if (result) {
                     const uris = [];
                     for (let i = 0; i < result.length; i++) {
-                        const uri = URI.parse('file://' + result[i]);
+                        const uri = URI.file(result[i]);
                         uris.push(uri);
                     }
                     resolve(uris);

package/src/plugin/documents.ts

@@ -158,7 +158,7 @@ export class DocumentsExtImpl implements DocumentsExt {
         const uriString = uri.toString();
         const data = this.editorsAndDocuments.getDocument(uriString);
         if (!data) {
-            throw new Error('unknown document');
+            throw new Error('unknown document: ' + uriString);
         }
         data.acceptIsDirty(isDirty);
         this._onDidChangeDocument.fire({
@@ -172,7 +172,7 @@ export class DocumentsExtImpl implements DocumentsExt {
         const uriString = uri.toString();
         const data = this.editorsAndDocuments.getDocument(uriString);
         if (!data) {
-            throw new Error('unknown document');
+            throw new Error('unknown document: ' + uriString);
         }
         data.acceptIsDirty(isDirty);
         data.onEvents(e);

package/src/plugin/editors-and-documents.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { inject, injectable } from '@theia/core/shared/inversify';
 import { EditorsAndDocumentsExt, EditorsAndDocumentsDelta, PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
 import { TextEditorExt } from './text-editor';
 import { RPCProtocol } from '../common/rpc-protocol';
@@ -24,7 +25,11 @@ import * as Converter from './type-converters';
 import { dispose } from '../common/disposable-util';
 import { URI } from './types-impl';
 
+@injectable()
 export class EditorsAndDocumentsExtImpl implements EditorsAndDocumentsExt {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
+
     private activeEditorId: string | null = null;
 
     private readonly _onDidAddDocuments = new Emitter<DocumentDataExt[]>();
@@ -40,9 +45,6 @@ export class EditorsAndDocumentsExtImpl implements EditorsAndDocumentsExt {
     private readonly documents = new Map<string, DocumentDataExt>();
     private readonly editors = new Map<string, TextEditorExt>();
 
-    constructor(private readonly rpc: RPCProtocol) {
-    }
-
     async $acceptEditorsAndDocumentsDelta(delta: EditorsAndDocumentsDelta): Promise<void> {
         const removedDocuments = new Array<DocumentDataExt>();
         const addedDocuments = new Array<DocumentDataExt>();

package/src/plugin/env.ts

@@ -14,13 +14,18 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import * as theia from '@theia/plugin';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { EnvMain, PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
 import { QueryParameters } from '../common/env';
-import { v4 } from 'uuid';
+import { generateUuid } from '@theia/core/lib/common/uuid';
 
+@injectable()
 export abstract class EnvExtImpl {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
+
     private proxy: EnvMain;
     private queryParameters: QueryParameters;
     private lang: string;
@@ -29,15 +34,20 @@ export abstract class EnvExtImpl {
     private envMachineId: string;
     private envSessionId: string;
     private host: string;
+    private applicationRoot: string;
     private _remoteName: string | undefined;
 
-    constructor(rpc: RPCProtocol) {
-        this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.ENV_MAIN);
-        this.envSessionId = v4();
-        this.envMachineId = v4();
+    constructor() {
+        this.envSessionId = generateUuid();
+        this.envMachineId = generateUuid();
         this._remoteName = undefined;
     }
 
+    @postConstruct()
+    initialize(): void {
+        this.proxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.ENV_MAIN);
+    }
+
     getEnvVariable(envVarName: string): Promise<string | undefined> {
         return this.proxy.$getEnvVariable(envVarName).then(x => {
             if (x === null) {
@@ -75,6 +85,10 @@ export abstract class EnvExtImpl {
         this.host = appHost;
     }
 
+    setAppRoot(appRoot: string): void {
+        this.applicationRoot = appRoot;
+    }
+
     getClientOperatingSystem(): Promise<theia.OperatingSystem> {
         return this.proxy.$getClientOperatingSystem();
     }
@@ -83,7 +97,9 @@ export abstract class EnvExtImpl {
         return this.applicationName;
     }
 
-    abstract get appRoot(): string;
+    get appRoot(): string {
+        return this.applicationRoot;
+    }
 
     abstract get isNewAppInstall(): boolean;
 

package/src/plugin/file-system-ext-impl.ts

@@ -41,6 +41,7 @@ import { commonPrefixLength } from '@theia/core/lib/common/strings';
 import { CharCode } from '@theia/core/lib/common/char-code';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
 import { Emitter } from '@theia/core/shared/vscode-languageserver-protocol';
+import { MarkdownString } from '../common/plugin-api-rpc-model';
 
 type IDisposable = vscode.Disposable;
 
@@ -223,7 +224,7 @@ export class FileSystemExtImpl implements FileSystemExt {
         this.onWillRegisterFileSystemProviderEmitter.dispose();
     }
 
-    registerFileSystemProvider(scheme: string, provider: vscode.FileSystemProvider, options: { isCaseSensitive?: boolean, isReadonly?: boolean } = {}) {
+    registerFileSystemProvider(scheme: string, provider: vscode.FileSystemProvider, options: { isCaseSensitive?: boolean, isReadonly?: boolean | MarkdownString } = {}) {
 
         if (this._usedSchemes.has(scheme)) {
             throw new Error(`a provider for the scheme '${scheme}' is already registered`);
@@ -252,7 +253,19 @@ export class FileSystemExtImpl implements FileSystemExt {
             capabilities += files.FileSystemProviderCapabilities.FileOpenReadWriteClose;
         }
 
-        this._proxy.$registerFileSystemProvider(handle, scheme, capabilities);
+        let readonlyMessage: MarkdownString | undefined;
+        if (options.isReadonly && MarkdownString.is(options.isReadonly)) {
+            readonlyMessage = {
+                value: options.isReadonly.value,
+                isTrusted: options.isReadonly.isTrusted,
+                supportThemeIcons: options.isReadonly.supportThemeIcons,
+                supportHtml: options.isReadonly.supportHtml,
+                baseUri: options.isReadonly.baseUri,
+                uris: options.isReadonly.uris
+            };
+        }
+
+        this._proxy.$registerFileSystemProvider(handle, scheme, capabilities, readonlyMessage);
 
         const subscription = provider.onDidChangeFile(event => {
             const mapped: IFileChangeDto[] = [];

package/src/plugin/known-commands.ts

@@ -261,6 +261,7 @@ export namespace KnownCommands {
     mappings['closeReferenceSearch'] = ['closeReferenceSearch', CONVERT_VSCODE_TO_MONACO];
     mappings['goToNextReference'] = ['goToNextReference', CONVERT_VSCODE_TO_MONACO];
     mappings['goToPreviousReference'] = ['goToPreviousReference', CONVERT_VSCODE_TO_MONACO];
+    mappings['setContext'] = ['_setContext', CONVERT_VSCODE_TO_MONACO];
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const CONVERT_MONACO_TO_VSCODE = (args: any | undefined) => {

package/src/plugin/languages/diagnostics.ts

@@ -22,7 +22,7 @@ import { MarkerData } from '../../common/plugin-api-rpc-model';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { PLUGIN_RPC_CONTEXT, LanguagesMain } from '../../common/plugin-api-rpc';
 import { URI } from '@theia/core/shared/vscode-uri';
-import { v4 } from 'uuid';
+import { generateUuid } from '@theia/core/lib/common/uuid';
 
 export class DiagnosticCollection implements theia.DiagnosticCollection {
     private static DIAGNOSTICS_PRIORITY = [
@@ -288,7 +288,7 @@ export class Diagnostics {
     }
 
     private getNextId(): string {
-        return v4();
+        return generateUuid();
     }
 
     private getAllDiagnosticsForResource(uri: URI): theia.Diagnostic[] {

package/src/plugin/languages/link-provider.ts

@@ -33,7 +33,9 @@ export class LinkProviderAdapter {
     provideLinks(resource: URI, token: theia.CancellationToken): Promise<DocumentLink[] | undefined> {
         const document = this.documents.getDocumentData(resource);
         if (!document) {
-            return Promise.reject(new Error(`There is no document for ${resource}`));
+            // not all documents are replicated to the plugin host (e.g. breakpoint input)
+            console.warn(`There is no document for ${resource}`);
+            return Promise.resolve(undefined);
         }
 
         const doc = document.document;

package/src/plugin/localization-ext.ts

@@ -16,6 +16,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { nls } from '@theia/core';
 import { Localization } from '@theia/core/lib/common/i18n/localization';
 import { LocalizationExt, LocalizationMain, Plugin, PLUGIN_RPC_CONTEXT, StringDetails } from '../common';
@@ -23,15 +24,19 @@ import { LanguagePackBundle } from '../common/language-pack-service';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { URI } from './types-impl';
 
+@injectable()
 export class LocalizationExtImpl implements LocalizationExt {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
 
-    private readonly _proxy: LocalizationMain;
+    private _proxy: LocalizationMain;
     private currentLanguage?: string;
     private isDefaultLanguage = true;
     private readonly bundleCache = new Map<string, LanguagePackBundle | undefined>();
 
-    constructor(rpc: RPCProtocol) {
-        this._proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.LOCALIZATION_MAIN);
+    @postConstruct()
+    initialize(): void {
+        this._proxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.LOCALIZATION_MAIN);
     }
 
     translateMessage(pluginId: string, details: StringDetails): string {

package/src/plugin/markdown-string.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { Mutable } from '@theia/core';
-import { MarkdownStringImpl as BaseMarkdownString, MarkdownString as MarkdownStringInterface } from '@theia/core/lib/common/markdown-rendering';
+import { MarkdownStringImpl as BaseMarkdownString, MarkdownString as MarkdownStringInterface, MarkdownStringTrustedOptions } from '@theia/core/lib/common/markdown-rendering';
 import * as pluginAPI from '@theia/plugin';
 import { es5ClassCompat } from '../common/types';
 import { URI } from './types-impl';
@@ -49,11 +49,11 @@ export class MarkdownString implements pluginAPI.MarkdownString {
         this.#delegate.value = value;
     }
 
-    get isTrusted(): boolean | undefined {
+    get isTrusted(): boolean | MarkdownStringTrustedOptions | undefined {
         return this.#delegate.isTrusted;
     }
 
-    set isTrusted(value: boolean | undefined) {
+    set isTrusted(value: boolean | MarkdownStringTrustedOptions | undefined) {
         this.#delegate.isTrusted = value;
     }
 

package/src/plugin/message-registry.ts

@@ -13,18 +13,23 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import {
     PLUGIN_RPC_CONTEXT as Ext, MessageRegistryMain, MainMessageOptions, MainMessageType
 } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { MessageItem, MessageOptions } from '@theia/plugin';
 
+@injectable()
 export class MessageRegistryExt {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
 
     private proxy: MessageRegistryMain;
 
-    constructor(rpc: RPCProtocol) {
-        this.proxy = rpc.getProxy(Ext.MESSAGE_REGISTRY_MAIN);
+    @postConstruct()
+    initialize(): void {
+        this.proxy = this.rpc.getProxy(Ext.MESSAGE_REGISTRY_MAIN);
     }
 
     async showMessage(type: MainMessageType, message: string,

package/src/plugin/node/debug/debug.spec.ts

@@ -13,6 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Container } from '@theia/core/shared/inversify';
 import { DebugSession } from '@theia/plugin';
 import * as chai from 'chai';
 import { ProxyIdentifier, RPCProtocol } from '../../../common/rpc-protocol';
@@ -37,7 +38,10 @@ describe('Debug API', () => {
             }
         };
 
-        const debug = new DebugExtImpl(mockRPCProtocol);
+        const container = new Container();
+        container.bind(RPCProtocol).toConstantValue(mockRPCProtocol);
+        container.bind(DebugExtImpl).toSelf().inSingletonScope();
+        const debug = container.get(DebugExtImpl);
 
         it('should use sourceReference, path and sessionId', () => {
             const source = {

package/src/plugin/node/env-node-ext.ts

@@ -14,27 +14,29 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { injectable } from '@theia/core/shared/inversify';
 import * as mac from 'macaddress';
 import { EnvExtImpl } from '../env';
-import { RPCProtocol } from '../../common/rpc-protocol';
 import { createHash } from 'crypto';
-import { v4 } from 'uuid';
+import { generateUuid } from '@theia/core/lib/common/uuid';
 import fs = require('fs');
 
 /**
  * Provides machineId using mac address. It's only possible on node side
  * Extending the common class
  */
+@injectable()
 export class EnvNodeExtImpl extends EnvExtImpl {
 
     private macMachineId: string;
     private _isNewAppInstall: boolean;
 
-    constructor(rpc: RPCProtocol) {
-        super(rpc);
+    constructor() {
+        super();
+
         mac.one((err, macAddress) => {
             if (err) {
-                this.macMachineId = v4();
+                this.macMachineId = generateUuid();
             } else {
                 this.macMachineId = createHash('sha256').update(macAddress, 'utf8').digest('hex');
             }
@@ -49,13 +51,6 @@ export class EnvNodeExtImpl extends EnvExtImpl {
         return this.macMachineId;
     }
 
-    /**
-     * Provides application root.
-     */
-    get appRoot(): string {
-        return __dirname;
-    }
-
     get isNewAppInstall(): boolean {
         return this._isNewAppInstall;
     }

package/src/plugin/node/plugin-container-module.ts

@@ -0,0 +1,165 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { interfaces, ContainerModule } from '@theia/core/shared/inversify';
+import { Plugin, PluginManager, emptyPlugin } from '../../common';
+
+export type ApiFactory<T extends object> = (plugin: Plugin) => T;
+
+/**
+ * Bind a service identifier for the factory function creating API objects of
+ * type `T` for a client plugin to a class providing a `call()` method that
+ * implements that factory function.
+ *
+ * @template T the API object type that the factory creates
+ * @param serviceIdentifier the injection key identifying the API factory function
+ * @param factoryClass the class implementing the API factory function via its `call()` method
+ */
+export type BindApiFactory = <T extends object>(
+    apiModuleName: string,
+    serviceIdentifier: interfaces.ServiceIdentifier<ApiFactory<T>>,
+    factoryClass: new () => { createApi: ApiFactory<T>}) => void;
+
+/**
+ * An analogue of the callback function in the constructor of the Inversify
+ * `ContainerModule` providing a registry that, in addition to the standard
+ * binding-related functions, includes a custom function for binding an
+ * API factory.
+ */
+export type PluginContainerModuleCallBack = (registry: {
+    bind: interfaces.Bind;
+    unbind: interfaces.Unbind;
+    isBound: interfaces.IsBound;
+    rebind: interfaces.Rebind;
+    bindApiFactory: BindApiFactory;
+}) => void;
+
+/**
+ * Factory for an Inversify `ContainerModule` that supports registration of the plugin's
+ * API factory. Use the `PluginContainerModule`'s `create()` method to create the container
+ * module; its `callback` function provides a `registry` of Inversify binding functions that
+ * includes a `bindApiFactory` function for binding the API factory.
+ */
+export const PluginContainerModule: symbol & { create(callback: PluginContainerModuleCallBack): ContainerModule } = Object.assign(Symbol('PluginContainerModule'), {
+    create(callback: PluginContainerModuleCallBack): ContainerModule {
+        const result: InternalPluginContainerModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+            const bindApiFactory: BindApiFactory = (apiModuleName, serviceIdentifier, factoryClass) => {
+                result.initializeApi = container => {
+                    const apiCache = new PluginApiCache(apiModuleName, serviceIdentifier);
+                    apiCache.initializeApi(container);
+                    return apiCache;
+                };
+                bind(factoryClass).toSelf().inSingletonScope();
+                bind(serviceIdentifier).toDynamicValue(({ container }) => {
+                    const factory = container.get(factoryClass);
+                    return factory.createApi.bind(factory);
+                }).inSingletonScope();
+            };
+            callback({ bind, unbind, isBound, rebind, bindApiFactory });
+        });
+        return result;
+    }
+});
+
+/**
+ * Definition of additional API provided by the `ContainerModule` created by the
+ * {@link PluginContainerModule} factory function that is for internal use by Theia.
+ */
+export type InternalPluginContainerModule = ContainerModule & {
+    /** Use my API factory binding to initialize the plugin API in some `container`. */
+    initializeApi?: (container: interfaces.Container) => PluginApiCache<object>;
+};
+
+/**
+ * An object that creates and caches the instance of the plugin API created by the
+ * factory binding in a {@link PluginContainerModule} in some plugin host.
+ *
+ * @template T the custom API object's type
+ */
+export class PluginApiCache<T extends object> {
+
+    private apiFactory: ApiFactory<T>;
+    private pluginManager: PluginManager;
+    private defaultApi: T;
+    private pluginsApiImpl = new Map<string, T>();
+    private hookedModuleLoader = false;
+
+    /**
+     * Initializes me with the module name by which plugins import the API
+     * and the service identifier to look up in the Inversify `Container` to
+     * obtain the {@link ApiFactory} that will instantiate it.
+     */
+    constructor(private readonly apiModuleName: string,
+        private readonly serviceIdentifier: interfaces.ServiceIdentifier<ApiFactory<T>>) {}
+
+    // Called by Theia to do any prep work needed for dishing out the API object
+    // when it's requested. The key part of that is hooking into the node module
+    // loader. This is called every time a plugin-host process is forked.
+    initializeApi(container: interfaces.Container): void {
+        this.apiFactory = container.get(this.serviceIdentifier);
+        this.pluginManager = container.get(PluginManager);
+
+        if (!this.hookedModuleLoader) {
+            this.hookedModuleLoader = true;
+            this.overrideInternalLoad();
+        }
+    }
+
+    /**
+     * Hook into the override chain of JavaScript's `module` loading function
+     * to implement ourselves, using the API provider's registered factory,
+     * the construction of its default exports object.
+     */
+    private overrideInternalLoad(): void {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const module = require('module');
+
+        const internalLoad = module._load;
+        const self = this;
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        module._load = function (request: string, parent: any, isMain: any): any {
+            if (request !== self.apiModuleName) {
+                // Pass the request to the next implementation down the chain
+                return internalLoad.call(this, request, parent, isMain);
+            }
+
+            const plugin = self.findPlugin(parent.filename);
+            if (plugin) {
+                let apiImpl = self.pluginsApiImpl.get(plugin.model.id);
+                if (!apiImpl) {
+                    apiImpl = self.apiFactory(plugin);
+                    self.pluginsApiImpl.set(plugin.model.id, apiImpl);
+                }
+                return apiImpl;
+            }
+
+            console.warn(
+                `Extension module ${parent.filename} did an import of '${self.apiModuleName}' but our cache ` +
+                    ' has no knowledge of that extension. Returning a generic API object; some functionality might not work correctly.'
+            );
+            if (!self.defaultApi) {
+                self.defaultApi = self.apiFactory(emptyPlugin);
+            }
+            return self.defaultApi;
+        };
+    }
+
+    // Search all loaded plugins to see which one has the given file (absolute path)
+    protected findPlugin(filePath: string): Plugin | undefined {
+        return this.pluginManager.getAllPlugins().find(plugin => filePath.startsWith(plugin.pluginFolder));
+    }
+}

package/src/plugin/notebook/notebook-document.ts

@@ -287,7 +287,8 @@ export class NotebookDocument implements Disposable {
             } else if (rawEvent.kind === notebookCommon.NotebookCellsChangeType.Output) {
                 this.setCellOutputs(rawEvent.index, rawEvent.outputs);
                 relaxedCellChanges.push({ cell: this.cells[rawEvent.index].apiCell, outputs: this.cells[rawEvent.index].apiCell.outputs });
-
+            } else if (rawEvent.kind === notebookCommon.NotebookCellsChangeType.ChangeDocumentMetadata) {
+                this.metadata = result.metadata ?? {};
                 // } else if (rawEvent.kind === notebookCommon.NotebookCellsChangeType.OutputItem) {
                 //     this._setCellOutputItems(rawEvent.index, rawEvent.outputId, rawEvent.append, rawEvent.outputItems);
                 //     relaxedCellChanges.push({ cell: this.cells[rawEvent.index].apiCell, outputs: this.cells[rawEvent.index].apiCell.outputs });
@@ -357,6 +358,18 @@ export class NotebookDocument implements Disposable {
                 const extCell = new Cell(this, this.editorsAndDocuments, cell);
                 if (!initialization) {
                     addedCellDocuments.push(Cell.asModelAddData(this.apiNotebook, cell));
+                    this.editorsAndDocuments.$acceptEditorsAndDocumentsDelta({
+                        addedDocuments: [
+                            {
+                                uri: cell.uri,
+                                versionId: 1,
+                                lines: cell.source,
+                                EOL: cell.eol,
+                                modeId: '',
+                                isDirty: false
+                            }
+                        ]
+                    });
                 }
                 return extCell;
             });